/home/coin/SVN-release/OS-2.3.5/OS/src/OSCommonInterfaces/OSOption.cpp

Go to the documentation of this file.
00001 /* $Id: OSOption.cpp 4120 2011-03-30 06:28:16Z kmartin $ */
00016 //#define DEBUG
00017 
00018 //#ifdef  DEBUG
00019 //#define DEBUG_OSOPTION
00020 //#endif
00021 
00022 #include "OSOption.h"
00023 #include "OSParameters.h"
00024 #include "OSGeneral.h"
00025 #include "OSErrorClass.h"
00026 #include "CoinFinite.hpp"
00027 #include <iostream> 
00028 #include <sstream>
00029 #include <limits>
00030 #include <cstdio>
00031 #include "OSMathUtil.h"
00032 
00033 using namespace std;
00034 
00035 InstanceLocationOption::InstanceLocationOption(): 
00036         locationType ("local"),
00037         value ("")
00038 {    
00039         #ifdef DEBUG_OSOPTION
00040         cout << "Inside InstanceLocationOption Constructor" << endl;
00041         #endif
00042 }// end InstanceLocationOption constructor  
00043 
00044 InstanceLocationOption::~InstanceLocationOption()
00045 {    
00046         #ifdef DEBUG_OSOPTION
00047         cout << "InstanceLocationOption Destructor Called" << endl;
00048         #endif
00049 }//end InstanceLocationOption destructor 
00050 
00051 
00052 ContactOption::ContactOption(): 
00053         transportType ("osp"),
00054         value ("")
00055 {    
00056         #ifdef DEBUG_OSOPTION
00057         cout << "Inside ContactOption Constructor" << endl;
00058         #endif
00059 }// end ContactOption constructor 
00060 
00061 ContactOption::~ContactOption()
00062 {    
00063         #ifdef DEBUG_OSOPTION
00064         cout << "ContactOption Destructor Called" << endl;
00065         #endif
00066 }//end ContactOption destructor
00067 
00068 
00069 OtherOption::OtherOption(): 
00070         name (""),
00071         value (""),
00072         description ("")
00073 {    
00074         #ifdef DEBUG_OSOPTION
00075         cout << "Inside OtherOption Constructor" << endl;
00076         #endif
00077 }// end OtherOption constructor 
00078 
00079 OtherOption::~OtherOption()
00080 {    
00081         #ifdef DEBUG_OSOPTION
00082         cout << "OtherOption Destructor Called" << endl;
00083         #endif
00084 }//end OtherOption destructor
00085 
00086 
00087 OtherOptions::OtherOptions(): 
00088         numberOfOtherOptions(0)
00089 {    
00090         #ifdef DEBUG_OSOPTION
00091         cout << "Inside OtherOptions Constructor" << endl;
00092         #endif
00093         other = NULL;
00094 }// end OtherOptions constructor 
00095 
00096 OtherOptions::~OtherOptions()
00097 {    
00098         #ifdef DEBUG_OSOPTION
00099         cout << "OtherOptions Destructor Called" << endl;
00100         #endif
00101 
00102         if (other != NULL)
00103         {       int i;
00104                 for (i=0; i<numberOfOtherOptions; i++)
00105                 {       delete other[i];
00106                         other[i] = NULL;
00107                 }
00108                 delete[] other;
00109                 other = NULL;
00110         }
00111 }//end OtherOptions destructor
00112 
00113 
00114 GeneralOption::GeneralOption(): 
00115         serviceURI (""),
00116         serviceName (""),
00117         instanceName (""),
00118         jobID (""),
00119         solverToInvoke (""),
00120         license (""),
00121         userName (""),
00122         password ("")
00123 {    
00124         #ifdef DEBUG_OSOPTION
00125         cout << "Inside GeneralOption Constructor" << endl;
00126         #endif
00127         instanceLocation = NULL;
00128         contact = NULL;
00129         otherOptions = NULL;
00130 }// end GeneralOption constructor  
00131 
00132 GeneralOption::~GeneralOption()
00133 {    
00134         #ifdef DEBUG_OSOPTION
00135         cout << "GeneralOption Destructor Called" << endl;
00136         #endif
00137         if (instanceLocation != NULL) delete instanceLocation;
00138         instanceLocation = NULL;
00139         if (contact != NULL) delete contact;
00140         contact = NULL;
00141         if (otherOptions != NULL) delete otherOptions;
00142         otherOptions = NULL;
00143 }//end GeneralOption destructor 
00144 
00145 
00146 MinDiskSpace::MinDiskSpace():
00147         unit ("byte"),
00148         description(""),
00149         value (0.0)
00150 {
00151         #ifdef DEBUG_OSOPTION
00152         cout << "Inside MinDiskSpace Constructor" << endl;
00153         #endif
00154 }// end MinDiskSpace constructor
00155 
00156 MinDiskSpace::~MinDiskSpace()
00157 {
00158         #ifdef DEBUG_OSOPTION
00159         cout << "MinDiskSpace Destructor Called" << endl;
00160         #endif
00161 }// end MinDiskSpace destructor
00162 
00163 
00164 MinMemorySize::MinMemorySize():
00165         unit ("byte"),
00166         description(""),
00167         value (0.0)
00168 {
00169         #ifdef DEBUG_OSOPTION
00170         cout << "Inside MinMemorySize Constructor" << endl;
00171         #endif
00172 }// end MinMemorySize constructor
00173 
00174 MinMemorySize::~MinMemorySize()
00175 {
00176         #ifdef DEBUG_OSOPTION
00177         cout << "MinMemorySize Destructor Called" << endl;
00178         #endif
00179 }// end MinMemorySize destructor
00180 
00181 
00182 MinCPUSpeed::MinCPUSpeed():
00183         unit ("hertz"),
00184         description(""),
00185         value (0.0)
00186 {
00187         #ifdef DEBUG_OSOPTION
00188         cout << "Inside MinCPUSpeed Constructor" << endl;
00189         #endif
00190 }// end MinCPUSpeed constructor
00191 
00192 MinCPUSpeed::~MinCPUSpeed()
00193 {
00194         #ifdef DEBUG_OSOPTION
00195         cout << "MinCPUSpeed Destructor Called" << endl;
00196         #endif
00197 }// end MinCPUSpeed destructor
00198 
00199 MinCPUNumber::MinCPUNumber():
00200         description(""),
00201         value (0)
00202 {
00203         #ifdef DEBUG_OSOPTION
00204         cout << "Inside MinCPUNumber Constructor" << endl;
00205         #endif
00206 }// end MinCPUNumber constructor
00207 
00208 MinCPUNumber::~MinCPUNumber()
00209 {
00210         #ifdef DEBUG_OSOPTION
00211         cout << "MinCPUNumber Destructor Called" << endl;
00212         #endif
00213 }// end MinCPUNumber destructor
00214 
00215 
00216 SystemOption::SystemOption() 
00217 {    
00218         #ifdef DEBUG_OSOPTION
00219         cout << "Inside SystemOption Constructor" << endl;
00220         #endif
00221         minDiskSpace = NULL;
00222         minMemorySize = NULL;
00223         minCPUSpeed = NULL;
00224         minCPUNumber = NULL;
00225         otherOptions = NULL;
00226 }// end SystemOption constructor  
00227 
00228 SystemOption::~SystemOption()
00229 {    
00230         #ifdef DEBUG_OSOPTION
00231         cout << "SystemOption Destructor Called" << endl;
00232         #endif
00233         if (minDiskSpace != NULL) delete minDiskSpace;
00234         minDiskSpace = NULL;
00235         if (minMemorySize != NULL) delete minMemorySize;
00236         minMemorySize = NULL;
00237         if (minCPUSpeed != NULL) delete minCPUSpeed;
00238         minCPUSpeed = NULL;
00239         if (minCPUNumber != NULL) delete minCPUNumber;
00240         minCPUNumber = NULL;
00241         if (otherOptions != NULL) delete otherOptions;
00242         otherOptions = NULL;
00243 }//end SystemOption destructor 
00244 
00245 
00246 ServiceOption::ServiceOption(): 
00247         type ("solver")
00248 {    
00249         #ifdef DEBUG_OSOPTION
00250         cout << "Inside ServiceOption Constructor" << endl;
00251         #endif
00252         otherOptions = NULL;
00253 }// end ServiceOption constructor  
00254 
00255 ServiceOption::~ServiceOption()
00256 {    
00257         #ifdef DEBUG_OSOPTION
00258         cout << "ServiceOption Destructor Called" << endl;
00259         #endif
00260         if (otherOptions != NULL) delete otherOptions;
00261         otherOptions = NULL;
00262 }//end ServiceOption destructor 
00263 
00264 
00265 JobDependencies::JobDependencies():
00266         numberOfJobIDs (0)
00267 {    
00268         #ifdef DEBUG_OSOPTION
00269         cout << "Inside JobDependencies Constructor" << endl;
00270         #endif
00271         jobID = NULL;
00272 }// end JobDependencies constructor  
00273 
00274 JobDependencies::~JobDependencies()
00275 {    
00276         #ifdef DEBUG_OSOPTION
00277         cout << "JobDependencies Destructor Called" << endl;
00278         #endif
00279 
00280         if (jobID != NULL) 
00281         {       delete[] jobID;
00282                 jobID = NULL;
00283         }
00284 }//end JobDependencies destructor 
00285 
00286 
00287 DirectoriesAndFiles::DirectoriesAndFiles():
00288         numberOfPaths (0)
00289 {    
00290         #ifdef DEBUG_OSOPTION
00291         cout << "Inside DirectoriesAndFiles Constructor" << endl;
00292         #endif
00293         path = NULL;
00294 }// end DirectoriesAndFiles constructor
00295 
00296 DirectoriesAndFiles::~DirectoriesAndFiles()
00297 {    
00298         #ifdef DEBUG_OSOPTION
00299         cout << "DirectoriesAndFiles Destructor Called" << endl;
00300         #endif
00301         if (path != NULL) 
00302         {       delete[] path;
00303                 path = NULL;
00304         }
00305 }//end DirectoriesAndFiles destructor 
00306 
00307 
00308 PathPair::PathPair():
00309         from (""),
00310         to (""),
00311         makeCopy (false)
00312 {    
00313         #ifdef DEBUG_OSOPTION
00314         cout << "Inside PathPair Constructor" << endl;
00315         #endif
00316 }// end PathPair constructor  
00317 
00318 PathPair::~PathPair()
00319 {    
00320         #ifdef DEBUG_OSOPTION
00321         cout << "PathPair Destructor Called" << endl;
00322         #endif
00323 }//end PathPair destructor 
00324 
00325 
00326 PathPairs::PathPairs():
00327         numberOfPathPairs(0)
00328 {    
00329         #ifdef DEBUG_OSOPTION
00330         cout << "Inside PathPairs Constructor" << endl;
00331         #endif
00332         pathPair = NULL;
00333 }// end PathPairs constructor  
00334 
00335 PathPairs::~PathPairs()
00336 {    
00337         #ifdef DEBUG_OSOPTION
00338         cout << "PathPairs Destructor Called" << endl;
00339         #endif
00340         int i;
00341         if (pathPair != NULL) 
00342         {       for (i=0; i < numberOfPathPairs; i++)   
00343                 {       delete pathPair[i];
00344                         pathPair[i] = NULL;
00345                 }
00346                 delete[] pathPair;
00347                 pathPair = NULL;
00348         }
00349 }//end PathPairs destructor 
00350 
00351 
00352 
00353 Processes::Processes():
00354         numberOfProcesses(0)
00355 {    
00356         #ifdef DEBUG_OSOPTION
00357         cout << "Inside Processes Constructor" << endl;
00358         #endif
00359         process = NULL;
00360 }// end Processes constructor  
00361 
00362 Processes::~Processes()
00363 {    
00364         #ifdef DEBUG_OSOPTION
00365         cout << "Processes Destructor Called" << endl;
00366         #endif
00367         if (process != NULL) 
00368         {       delete[] process;
00369                 process = NULL;
00370         }
00371 }//end Processes destructor 
00372 
00373 
00374 JobOption::JobOption():
00375         requestedStartTime("")
00376 {    
00377         #ifdef DEBUG_OSOPTION
00378         cout << "Inside JobOption Constructor" << endl;
00379         #endif
00380         maxTime = NULL;
00381         dependencies = NULL;
00382         requiredDirectories = NULL;
00383         requiredFiles = NULL;
00384         directoriesToMake = NULL;
00385         filesToMake = NULL;
00386         inputDirectoriesToMove = NULL;
00387         inputFilesToMove = NULL;
00388         outputFilesToMove = NULL;
00389         outputDirectoriesToMove = NULL;
00390         filesToDelete = NULL;
00391         directoriesToDelete = NULL;
00392         processesToKill = NULL;
00393         otherOptions = NULL;
00394 }// end JobOption constructor  
00395 
00396 JobOption::~JobOption()
00397 {    
00398         #ifdef DEBUG_OSOPTION
00399         cout << "JobOption Destructor Called" << endl;
00400         #endif
00401         if (maxTime != NULL) delete maxTime;
00402         maxTime = NULL;
00403         if (dependencies != NULL) delete dependencies;
00404         dependencies = NULL;
00405         if (requiredDirectories != NULL) delete requiredDirectories;
00406         requiredDirectories = NULL;
00407         if (requiredFiles != NULL) delete requiredFiles;
00408         requiredFiles = NULL;
00409         if (directoriesToMake != NULL) delete directoriesToMake;
00410         directoriesToMake = NULL;
00411         if (filesToMake != NULL) delete filesToMake;
00412         filesToMake = NULL;
00413         if (inputDirectoriesToMove != NULL) delete inputDirectoriesToMove;
00414         inputDirectoriesToMove = NULL;
00415         if (inputFilesToMove != NULL) delete inputFilesToMove;
00416         inputFilesToMove = NULL;
00417         if (outputDirectoriesToMove != NULL) delete outputDirectoriesToMove;
00418         outputDirectoriesToMove = NULL;
00419         if (outputFilesToMove != NULL) delete outputFilesToMove;
00420         outputFilesToMove = NULL;
00421         if (filesToDelete != NULL) delete filesToDelete;
00422         filesToDelete = NULL;
00423         if (directoriesToDelete != NULL) delete directoriesToDelete;
00424         directoriesToDelete = NULL;
00425         if (processesToKill != NULL) delete processesToKill;
00426         processesToKill = NULL;
00427         if (otherOptions != NULL) delete otherOptions;
00428         otherOptions = NULL;
00429 }//end JobOption destructor 
00430 
00431 
00432 InitVarValue::InitVarValue(): 
00433         idx (-1),
00434         value (OSNAN)
00435 {    
00436         #ifdef DEBUG_OSOPTION
00437         cout << "Inside InitVarValue Constructor" << endl;
00438         #endif
00439 }// end InitVarValue constructor  
00440 
00441 InitVarValue::~InitVarValue()
00442 {    
00443         #ifdef DEBUG_OSOPTION
00444         cout << "InitVarValue Destructor Called" << endl;
00445         #endif
00446 }//end InitVarValue destructor 
00447 
00448 
00449 InitVariableValues::InitVariableValues():
00450         numberOfVar (0)
00451 {    
00452         #ifdef DEBUG_OSOPTION
00453         cout << "Inside InitVariableValues Constructor" << endl;
00454         #endif
00455         var = NULL;
00456 }// end InitVariableValues constructor  
00457 
00458 InitVariableValues::~InitVariableValues()
00459 {    
00460         #ifdef DEBUG_OSOPTION
00461         cout << "InitVariableValues Destructor Called" << endl;
00462         #endif
00463         int i;
00464         if (var != NULL) 
00465         {       for (i=0; i < numberOfVar; i++)
00466                 {       delete var[i];
00467                         var[i] = NULL;
00468                 }
00469                 delete[] var;
00470                 var = NULL;
00471         }
00472 }//end InitVariableValues destructor 
00473 
00474 
00475 InitVarValueString::InitVarValueString(): 
00476         idx (-1),
00477         value ("")
00478 {    
00479         #ifdef DEBUG_OSOPTION
00480         cout << "Inside InitVarValueString Constructor" << endl;
00481         #endif
00482 }// end InitVarValueString constructor  
00483 
00484 InitVarValueString::~InitVarValueString()
00485 {    
00486         #ifdef DEBUG_OSOPTION
00487         cout << "InitVarValueString Destructor Called" << endl;
00488         #endif
00489 }//end InitVarValueString destructor 
00490 
00491 
00492 InitVariableValuesString::InitVariableValuesString():
00493         numberOfVar (0)
00494 {    
00495         #ifdef DEBUG_OSOPTION
00496         cout << "Inside InitVariableValuesString Constructor" << endl;
00497         #endif
00498         var = NULL;
00499 }// end InitVariableValuesString constructor  
00500 
00501 InitVariableValuesString::~InitVariableValuesString()
00502 {    
00503         #ifdef DEBUG_OSOPTION
00504         cout << "InitVariableValuesString Destructor Called" << endl;
00505         #endif
00506         int i;
00507         if (var != NULL) 
00508         {       for (i=0; i < numberOfVar; i++)
00509                 {       delete var[i];
00510                         var[i] = NULL;
00511                 }
00512                 delete[] var;
00513                 var = NULL;
00514         }
00515 }//end InitVariableValues destructor 
00516 
00517 InitBasStatus::InitBasStatus(): 
00518         idx (-1),
00519         value ("unknown")
00520 {    
00521         #ifdef DEBUG_OSOPTION
00522         cout << "Inside InitBasStatus Constructor" << endl;
00523         #endif
00524 }// end InitBasStatus constructor  
00525 
00526 InitBasStatus::~InitBasStatus()
00527 {    
00528         #ifdef DEBUG_OSOPTION
00529         cout << "InitBasStatus Destructor Called" << endl;
00530         #endif
00531 }//end InitBasStatus destructor 
00532 
00533 
00534 InitialBasisStatus::InitialBasisStatus():
00535         numberOfVar (0)
00536 {    
00537         #ifdef DEBUG_OSOPTION
00538         cout << "Inside InitialBasisStatus Constructor" << endl;
00539         #endif
00540         var = NULL;
00541 }// end InitialBasisStatus constructor  
00542 
00543 InitialBasisStatus::~InitialBasisStatus()
00544 {    
00545         #ifdef DEBUG_OSOPTION
00546         cout << "InitialBasisStatus Destructor Called" << endl;
00547         #endif
00548         if (var != NULL) 
00549         {       int i;
00550                 for (i=0; i < numberOfVar; i++)
00551                 {       delete var[i];
00552                         var[i] = NULL;
00553                 }
00554                 delete[] var;
00555                 var = NULL;
00556         }
00557 }//end InitialBasisStatus destructor 
00558 
00559 BranchingWeight::BranchingWeight(): 
00560         idx (-1),
00561         value (0.0)
00562 {    
00563         #ifdef DEBUG_OSOPTION
00564         cout << "Inside BranchingWeight Constructor" << endl;
00565         #endif
00566 }// end BranchingWeight constructor  
00567 
00568 BranchingWeight::~BranchingWeight()
00569 {    
00570         #ifdef DEBUG_OSOPTION
00571         cout << "BranchingWeight Destructor Called" << endl;
00572         #endif
00573 }//end BranchingWeight destructor 
00574 
00575 
00576 IntegerVariableBranchingWeights::IntegerVariableBranchingWeights():
00577         numberOfVar (0)
00578 {    
00579         #ifdef DEBUG_OSOPTION
00580         cout << "Inside IntegerVariableBranchingWeights Constructor" << endl;
00581         #endif
00582         var = NULL;
00583 }// end IntegerVariableBranchingWeights constructor  
00584 
00585 IntegerVariableBranchingWeights::~IntegerVariableBranchingWeights()
00586 {    
00587         #ifdef DEBUG_OSOPTION
00588         cout << "IntegerVariableBranchingWeights Destructor Called; numberOfVar=" << numberOfVar << endl;
00589         #endif
00590         if (var != NULL) 
00591         {       int i;
00592                 for (i=0; i < numberOfVar; i++)
00593                 {       delete var[i];
00594                         var[i] = NULL;
00595                 }
00596                 delete[] var;
00597                 var = NULL;
00598         }
00599 }//end IntegerVariableBranchingWeights destructor 
00600 
00601 SOSWeights::SOSWeights():
00602         sosIdx (-1),
00603         groupWeight (1.0),
00604         numberOfVar (0)
00605 {    
00606         #ifdef DEBUG_OSOPTION
00607         cout << "Inside SOSWeights Constructor" << endl;
00608         #endif
00609         var = NULL;
00610 }// end SOSWeights constructor  
00611 
00612 SOSWeights::~SOSWeights()
00613 {    
00614         #ifdef DEBUG_OSOPTION
00615         cout << "SOSWeights Destructor Called" << endl;
00616         #endif
00617         if (var != NULL) 
00618         {       int i;
00619                 for (i=0; i < numberOfVar; i++)
00620                 {       delete var[i];
00621                         var[i] = NULL;
00622                 }
00623                 delete[] var;
00624                 var = NULL;
00625         }
00626 }//end SOSWeights destructor 
00627 
00628 SOSVariableBranchingWeights::SOSVariableBranchingWeights():
00629         numberOfSOS (0)
00630 {    
00631         #ifdef DEBUG_OSOPTION
00632         cout << "Inside SOSVariableBranchingWeights Constructor" << endl;
00633         #endif
00634         sos = NULL;
00635 }// end SOSVariableBranchingWeights constructor  
00636 
00637 SOSVariableBranchingWeights::~SOSVariableBranchingWeights()
00638 {    
00639         #ifdef DEBUG_OSOPTION
00640         cout << "SOSVariableBranchingWeights Destructor Called" << endl;
00641         #endif
00642         if (sos != NULL) 
00643         {       int i;
00644                 for (i=0; i < numberOfSOS; i++)
00645                 {       delete sos[i];
00646                         sos[i] = NULL;
00647                 }
00648                 delete[] sos;
00649                 sos = NULL;
00650         }
00651 }//end SOSVariableBranchingWeights destructor 
00652 
00653 OtherVarOption::OtherVarOption(): 
00654         idx (0),
00655         value (""),
00656         lbValue (""),
00657         ubValue ("")
00658 {    
00659         #ifdef DEBUG_OSOPTION
00660         cout << "Inside OtherVarOption Constructor" << endl;
00661         #endif
00662 }// end OtherVarOption constructor  
00663 
00664 OtherVarOption::~OtherVarOption()
00665 {    
00666         #ifdef DEBUG_OSOPTION
00667         cout << "OtherVarOption Destructor Called" << endl;
00668         #endif
00669 }//end OtherVarOption destructor 
00670 
00671 
00672 OtherVariableOption::OtherVariableOption(): 
00673         numberOfVar(0),
00674         numberOfEnumerations(0),
00675         name (""),
00676         value (""),
00677         solver(""),
00678         category (""),
00679         type ("string"),
00680         description ("")
00681 {    
00682         #ifdef DEBUG_OSOPTION
00683         cout << "Inside OtherVariableOption Constructor" << endl;
00684         #endif
00685         var = NULL;
00686         enumeration = NULL;
00687 }// end OtherVariableOption constructor  
00688 
00689 OtherVariableOption::~OtherVariableOption()
00690 {    
00691         #ifdef DEBUG_OSOPTION
00692         cout << "OtherVariableOption Destructor Called" << endl;
00693         #endif
00694         if (var != NULL) 
00695         {
00696                 for (int i=0; i < numberOfVar; i++)
00697                 {       delete var[i];
00698                         var[i] = NULL;
00699                 }
00700                 delete[] var;
00701                 var = NULL;
00702         }
00703         if (enumeration != NULL) 
00704         {
00705                 for (int i=0; i < numberOfEnumerations; i++)
00706                 {
00707                         delete enumeration[i];
00708                         enumeration[i] = NULL;
00709                 }
00710                 delete[] enumeration;
00711                 enumeration = NULL;
00712         }
00713 }//end OtherVariableOption destructor 
00714 
00715 
00716 VariableOption::VariableOption():
00717         numberOfOtherVariableOptions(0)
00718 {    
00719         #ifdef DEBUG_OSOPTION
00720         cout << "Inside VariableOption Constructor" << endl;
00721         #endif
00722         initialVariableValues = NULL;
00723         initialVariableValuesString = NULL;
00724         initialBasisStatus = NULL;
00725         integerVariableBranchingWeights = NULL;
00726         sosVariableBranchingWeights = NULL;
00727         other = NULL;
00728 }// end VariableOption constructor  
00729 
00730 VariableOption::~VariableOption()
00731 {    
00732         #ifdef DEBUG_OSOPTION
00733         cout << "VariableOption Destructor Called" << endl;
00734         #endif
00735         if (initialVariableValues != NULL) delete initialVariableValues;
00736         initialVariableValues = NULL;
00737         if (initialVariableValuesString != NULL) delete initialVariableValuesString;
00738         initialVariableValuesString = NULL;
00739         if (initialBasisStatus != NULL) delete initialBasisStatus;
00740         initialBasisStatus = NULL;
00741         if (integerVariableBranchingWeights != NULL) delete integerVariableBranchingWeights;
00742         integerVariableBranchingWeights = NULL;
00743         if (sosVariableBranchingWeights != NULL) delete sosVariableBranchingWeights;
00744         sosVariableBranchingWeights = NULL;
00745         if (other != NULL) 
00746         {   int i;
00747                 for (i=0; i < numberOfOtherVariableOptions; i++)
00748                 {       if (other[i] != NULL)
00749                                 delete other[i];
00750                                 other[i] = NULL;
00751                 
00752                 };
00753                 delete[] other;
00754                 other = NULL;
00755         };
00756 }//end VariableOption destructor 
00757 
00758 
00759 InitObjValue::InitObjValue(): 
00760         idx (-1),
00761         value (OSNAN)
00762 {    
00763         #ifdef DEBUG_OSOPTION
00764         cout << "Inside InitObjValue Constructor" << endl;
00765         #endif
00766 }// end InitObjValue constructor  
00767 
00768 InitObjValue::~InitObjValue()
00769 {    
00770         #ifdef DEBUG_OSOPTION
00771         cout << "InitObjValue Destructor Called" << endl;
00772         #endif
00773 }//end InitObjValue destructor 
00774 
00775 
00776 InitObjectiveValues::InitObjectiveValues():
00777         numberOfObj (0)
00778 {    
00779         #ifdef DEBUG_OSOPTION
00780         cout << "Inside InitObjectiveValues Constructor" << endl;
00781         #endif
00782         obj = NULL;
00783 }// end InitObjectiveValues constructor  
00784 
00785 InitObjectiveValues::~InitObjectiveValues()
00786 {    
00787         #ifdef DEBUG_OSOPTION
00788         cout << "InitObjectiveValues Destructor Called" << endl;
00789         #endif
00790         if (obj != NULL) 
00791         {       int i;
00792                 for (i=0; i < numberOfObj; i++)
00793                 {       delete obj[i];
00794                         obj[i] = NULL;
00795                 }
00796                 delete[] obj;
00797                 obj = NULL;
00798         };
00799 }//end InitObjectiveValues destructor 
00800 
00801 
00802 InitObjBound::InitObjBound(): 
00803         idx (-1),
00804         lbValue (-OSDBL_MAX),
00805         ubValue ( OSDBL_MAX)
00806 {    
00807         #ifdef DEBUG_OSOPTION
00808         cout << "Inside InitObjBound Constructor" << endl;
00809         #endif
00810 }// end  constructor  template
00811 
00812 InitObjBound::~InitObjBound()
00813 {    
00814         #ifdef DEBUG_OSOPTION
00815         cout << "InitObjBound Destructor Called" << endl;
00816         #endif
00817 }//end InitObjBound destructor 
00818 
00819 
00820 InitObjectiveBounds::InitObjectiveBounds():
00821         numberOfObj (0)
00822 {    
00823         #ifdef DEBUG_OSOPTION
00824         cout << "Inside InitObjectiveBounds Constructor" << endl;
00825         #endif
00826         obj = NULL;
00827 }// end InitObjectiveBounds constructor  
00828 
00829 InitObjectiveBounds::~InitObjectiveBounds()
00830 {    
00831         #ifdef DEBUG_OSOPTION
00832         cout << "InitObjectiveBounds Destructor Called" << endl;
00833         #endif
00834         if (obj != NULL) 
00835         {       int i;
00836                 for (i=0; i < numberOfObj; i++)
00837                 {       delete obj[i];
00838                         obj[i] = NULL;
00839                 }
00840                 delete[] obj;
00841                 obj = NULL;
00842         };
00843 }//end InitObjectiveBounds destructor 
00844 
00845 
00846 OtherObjOption::OtherObjOption(): 
00847         idx (-1),
00848         value (""),
00849         lbValue (""),
00850         ubValue ("")
00851 {    
00852         #ifdef DEBUG_OSOPTION
00853         cout << "Inside OtherObjOption Constructor" << endl;
00854         #endif
00855 }// end OtherObjOption constructor  
00856 
00857 OtherObjOption::~OtherObjOption()
00858 {    
00859         #ifdef DEBUG_OSOPTION
00860         cout << "OtherObjOption Destructor Called" << endl;
00861         #endif
00862 }//end OtherObjOption destructor 
00863 
00864 
00865 OtherObjectiveOption::OtherObjectiveOption(): 
00866         numberOfObj(0),
00867         numberOfEnumerations(0),
00868         name (""),
00869         value (""),
00870         solver(""),
00871         category (""),
00872         type ("string"),
00873         description ("")
00874 {    
00875         #ifdef DEBUG_OSOPTION
00876         cout << "Inside OtherObjectiveOption Constructor" << endl;
00877         #endif
00878         obj = NULL;
00879         enumeration = NULL;
00880 }// end OtherObjectiveOption constructor  
00881 
00882 OtherObjectiveOption::~OtherObjectiveOption()
00883 {    
00884         #ifdef DEBUG_OSOPTION
00885         cout << "OtherObjectiveOption Destructor Called" << endl;
00886         #endif
00887         if (obj != NULL) 
00888         {
00889                 for (int i=0; i < numberOfObj; i++)
00890                 {       delete obj[i];
00891                         obj[i] = NULL;
00892                 }
00893                 delete[] obj;
00894                 obj = NULL;
00895         }
00896         if (enumeration != NULL) 
00897         {
00898                 for (int i=0; i < numberOfEnumerations; i++)
00899                 {
00900                         delete enumeration[i];
00901                         enumeration[i] = NULL;
00902                 }
00903                 delete[] enumeration;
00904                 enumeration = NULL;
00905         }
00906 }//end OtherObjectiveOption destructor 
00907 
00908 
00909 ObjectiveOption::ObjectiveOption(): 
00910         numberOfOtherObjectiveOptions (0)
00911 {    
00912         #ifdef DEBUG_OSOPTION
00913         cout << "Inside ObjectiveOption Constructor" << endl;
00914         #endif
00915         initialObjectiveValues = NULL;
00916         initialObjectiveBounds = NULL;
00917         initialBasisStatus = NULL;
00918         other = NULL;
00919 }// end ObjectiveOption constructor  
00920 
00921 ObjectiveOption::~ObjectiveOption()
00922 {    
00923         #ifdef DEBUG_OSOPTION
00924         cout << "ObjectiveOption Destructor Called" << endl;
00925         #endif
00926         if (initialObjectiveValues != NULL) delete initialObjectiveValues;
00927         initialObjectiveValues = NULL;
00928         if (initialObjectiveBounds != NULL) delete initialObjectiveBounds;
00929         initialObjectiveBounds = NULL;
00930         if (initialBasisStatus != NULL) delete initialBasisStatus;
00931         initialBasisStatus = NULL;
00932         if (other != NULL) 
00933         {       int i;
00934                 for (i=0; i < numberOfOtherObjectiveOptions; i++)
00935                 {       delete other[i];
00936                         other[i] = NULL;
00937                 }
00938                 delete[] other;
00939                 other = NULL;
00940         }
00941 }//end ObjectiveOption destructor 
00942 
00943 
00944 InitConValue::InitConValue(): 
00945         idx (0),
00946         value (OSNAN)
00947 {    
00948         #ifdef DEBUG_OSOPTION
00949         cout << "Inside InitConValue Constructor" << endl;
00950         #endif
00951 }// end InitConValue constructor  
00952 
00953 InitConValue::~InitConValue()
00954 {    
00955         #ifdef DEBUG_OSOPTION
00956         cout << "InitConValue Destructor Called" << endl;
00957         #endif
00958 }//end InitConValue destructor 
00959 
00960 
00961 InitConstraintValues::InitConstraintValues(): 
00962         numberOfCon (0)
00963 {    
00964         #ifdef DEBUG_OSOPTION
00965         cout << "Inside InitConstraintValues Constructor" << endl;
00966         #endif
00967         con = NULL;
00968 }// end InitConstraintValues constructor  
00969 
00970 InitConstraintValues::~InitConstraintValues()
00971 {    
00972         #ifdef DEBUG_OSOPTION
00973         cout << "InitConstraintValues Destructor Called" << endl;
00974         #endif
00975         if (con != NULL) 
00976         {       int i;
00977                 for (i=0; i < numberOfCon; i++)
00978                 {       delete con[i];
00979                         con[i] = NULL;
00980                 }
00981                 delete[] con;
00982                 con = NULL;
00983         };
00984 }//end InitConstraintValues destructor
00985 
00986 
00987 InitDualVarValue::InitDualVarValue(): 
00988         idx (0),
00989         lbDualValue (0.0),
00990         ubDualValue (0.0)
00991 {    
00992         #ifdef DEBUG_OSOPTION
00993         cout << "Inside InitDualVarValue Constructor" << endl;
00994         #endif
00995 }// end InitDualVarValue constructor  
00996 
00997 InitDualVarValue::~InitDualVarValue()
00998 {    
00999         #ifdef DEBUG_OSOPTION
01000         cout << "InitDualVarValue Destructor Called" << endl;
01001         #endif
01002 }//end InitDualVarValue destructor
01003 
01004 
01005 InitDualVariableValues::InitDualVariableValues(): 
01006         numberOfCon (0)
01007 {    
01008         #ifdef DEBUG_OSOPTION
01009         cout << "Inside InitDualVariableValues Constructor" << endl;
01010         #endif
01011         con = NULL;
01012 }// end InitDualVariableValues constructor  
01013 
01014 InitDualVariableValues::~InitDualVariableValues()
01015 {    
01016         #ifdef DEBUG_OSOPTION
01017         cout << "InitDualVariableValues Destructor Called" << endl;
01018         #endif
01019         if (con != NULL) 
01020         {       int i;
01021                 for (i=0; i < numberOfCon; i++)
01022                 {       delete con[i];
01023                         con[i] = NULL;
01024                 }
01025                 delete[] con;
01026                 con = NULL;
01027         };
01028 }//end InitDualVariableValues destructor
01029 
01030 
01031 OtherConOption::OtherConOption(): 
01032         idx (0),
01033         value (""),
01034         lbValue (""),
01035         ubValue ("")
01036 {    
01037         #ifdef DEBUG_OSOPTION
01038         cout << "Inside OtherConOption Constructor" << endl;
01039         #endif
01040 }// end OtherConOption constructor  
01041 
01042 OtherConOption::~OtherConOption()
01043 {    
01044         #ifdef DEBUG_OSOPTION
01045         cout << "OtherConOption Destructor Called" << endl;
01046         #endif
01047 }//end OtherConOption destructor
01048 
01049 
01050 OtherConstraintOption::OtherConstraintOption(): 
01051         numberOfCon(0),
01052         numberOfEnumerations(0),
01053         name (""),
01054         value (""),
01055         solver(""),
01056         category (""),
01057         type ("string"),
01058         description ("")
01059 {    
01060         #ifdef DEBUG_OSOPTION
01061         cout << "Inside OtherConstraintOption Constructor" << endl;
01062         #endif
01063         con = NULL;
01064         enumeration = NULL;
01065 }// end OtherConstraintOption constructor  
01066 
01067 OtherConstraintOption::~OtherConstraintOption()
01068 {    
01069         #ifdef DEBUG_OSOPTION
01070         cout << "OtherConstraintOption Destructor Called" << endl;
01071         #endif
01072         if (con != NULL) 
01073         {
01074                 for (int i=0; i < numberOfCon; i++)
01075                 {
01076                         if (con[i]!= NULL) delete con[i];
01077                         con[i] = NULL;
01078                 }
01079                 delete[] con;
01080                 con = NULL;
01081         }
01082         if (enumeration != NULL) 
01083         {
01084                 for (int i=0; i < numberOfEnumerations; i++)
01085                 {
01086                         delete enumeration[i];
01087                         enumeration[i] = NULL;
01088                 }
01089                 delete[] enumeration;
01090                 enumeration = NULL;
01091         }
01092 }//end OtherConstraintOption destructor
01093 
01094 
01095 ConstraintOption::ConstraintOption(): 
01096         numberOfOtherConstraintOptions (0)
01097 {    
01098         #ifdef DEBUG_OSOPTION
01099         cout << "Inside ConstraintOption Constructor" << endl;
01100         #endif
01101         initialConstraintValues = NULL;
01102         initialDualValues = NULL;
01103         initialBasisStatus = NULL;
01104         other = NULL;
01105 }// end ConstraintOption constructor  
01106 
01107 ConstraintOption::~ConstraintOption()
01108 {    
01109         #ifdef DEBUG_OSOPTION
01110         cout << "ConstraintOption Destructor Called" << endl;
01111         #endif
01112         if (initialConstraintValues != NULL) delete initialConstraintValues;
01113         initialConstraintValues = NULL;
01114         if (initialDualValues != NULL) delete initialDualValues;
01115         initialDualValues = NULL;
01116         if (initialBasisStatus != NULL) delete initialBasisStatus;
01117         initialBasisStatus = NULL;
01118         if (other != NULL) 
01119         {       int i;
01120                 for (i=0; i < numberOfOtherConstraintOptions; i++)
01121                 {       delete other[i];
01122                         other[i] = NULL;
01123                 }
01124                 delete[] other;
01125                 other = NULL;
01126         }
01127 }//end ConstraintOption destructor
01128 
01129 
01130 SolverOption::SolverOption(): 
01131         name (""),
01132         value (""),
01133         solver(""),
01134         category (""),
01135         type (""),
01136         description (""),
01137         numberOfItems(0),
01138         item(NULL)
01139 {    
01140         #ifdef DEBUG_OSOPTION
01141         cout << "Inside SolverOption Constructor" << endl;
01142         #endif
01143 }// end SolverOption constructor  
01144 
01145 SolverOption::~SolverOption()
01146 {    
01147         #ifdef DEBUG_OSOPTION
01148         cout << "SolverOption Destructor Called" << endl;
01149         #endif
01150         if (item != NULL) delete[] item;
01151         item = NULL;
01152 }//end SolverOption destructor
01153 
01154 
01155 SolverOptions::SolverOptions(): 
01156         numberOfSolverOptions(0)
01157 {    
01158         #ifdef DEBUG_OSOPTION
01159         cout << "Inside SolverOptions Constructor" << endl;
01160         #endif
01161         solverOption = NULL;
01162 }// end SolverOptions constructor 
01163 
01164 SolverOptions::~SolverOptions()
01165 {    
01166         #ifdef DEBUG_OSOPTION
01167         cout << "SolverOptions Destructor Called; numberOfSolverOptions=" << numberOfSolverOptions << endl;
01168         #endif
01169         if (solverOption != NULL)
01170         {       int i;
01171                 for (i=0; i<numberOfSolverOptions; i++)
01172                 {       delete solverOption[i];
01173                         solverOption[i] = NULL;
01174                 }
01175                 delete[] solverOption;
01176                 solverOption = NULL;
01177         }
01178 }//end SolverOptions destructor
01179 
01180 
01181 OptimizationOption::OptimizationOption(): 
01182         numberOfVariables (-1),
01183         numberOfObjectives (-1),
01184         numberOfConstraints (-1)
01185 {    
01186         #ifdef DEBUG_OSOPTION
01187         cout << "Inside OptimizationOption Constructor" << endl;
01188         #endif
01189         variables = NULL;
01190         objectives = NULL;
01191         constraints = NULL;
01192         solverOptions = NULL;
01193 }// end OptimizationOption constructor  
01194 
01195 OptimizationOption::~OptimizationOption()
01196 {    
01197         #ifdef DEBUG_OSOPTION
01198         cout << "OptimizationOption Destructor Called" << endl;
01199         #endif
01200         if (variables != NULL) delete variables;
01201         variables = NULL;
01202         if (objectives != NULL) delete objectives;
01203         objectives = NULL;
01204         if (constraints != NULL) delete constraints;
01205         constraints = NULL;
01206         if (solverOptions != NULL) delete solverOptions;
01207         solverOptions = NULL;
01208 }//end OptimizationOption destructor
01209 
01210 
01211 OSOption::OSOption() 
01212 //(initializations)
01213 {    
01214         #ifdef DEBUG_OSOPTION
01215         cout << "Inside OSOption Constructor" << endl;
01216         #endif
01217 
01218         optionHeader = NULL;
01219         general = NULL;
01220         system = NULL;
01221         service = NULL;
01222         job = NULL;
01223         optimization = NULL;
01224         m_mdInitVarValuesDense = NULL;
01225         m_mdInitVarValuesStringDense = NULL;
01226         m_mdInitBasisStatusDense = NULL;
01227         m_mdIntegerVariableBranchingWeightsDense = NULL;
01228         m_mdInitObjValuesDense = NULL;
01229         m_mdInitObjLowerBoundsDense = NULL;
01230         m_mdInitObjUpperBoundsDense = NULL;
01231         m_mdInitConValuesDense = NULL;
01232         m_mdInitDualVarLowerBoundsDense = NULL;
01233         m_mdInitDualVarUpperBoundsDense = NULL;
01234 }// end OSOption constructor  
01235 
01236 OSOption::~OSOption()
01237 {    
01238         #ifdef DEBUG_OSOPTION
01239         cout << "OSOption Destructor Called" << endl;
01240         #endif
01241         if (optionHeader != NULL) delete optionHeader;
01242         optionHeader = NULL;
01243         if (general != NULL) delete general;
01244         general = NULL;
01245         if (system != NULL) delete system;
01246         system = NULL;
01247         if (service != NULL) delete service;
01248         service = NULL;
01249         if (job != NULL) delete job;
01250         job = NULL;
01251         if (optimization != NULL) delete optimization;
01252         optimization = NULL;
01253 
01254         if (m_mdInitVarValuesDense != NULL) 
01255                 delete[] m_mdInitVarValuesDense;
01256         m_mdInitVarValuesDense = NULL;
01257 
01258         if (m_mdInitVarValuesStringDense != NULL) 
01259                 delete[] m_mdInitVarValuesStringDense;
01260         m_mdInitVarValuesStringDense = NULL;
01261 
01262         if (m_mdInitBasisStatusDense != NULL) 
01263                 delete[] m_mdInitBasisStatusDense;
01264         m_mdInitBasisStatusDense = NULL;
01265 
01266         if (m_mdIntegerVariableBranchingWeightsDense != NULL) 
01267                 delete[] m_mdIntegerVariableBranchingWeightsDense;
01268         m_mdIntegerVariableBranchingWeightsDense = NULL;
01269 
01270         if (m_mdInitObjValuesDense != NULL) 
01271                 delete[] m_mdInitObjValuesDense;
01272         m_mdInitObjValuesDense = NULL;
01273 
01274         if (m_mdInitObjLowerBoundsDense != NULL) 
01275                 delete[] m_mdInitObjLowerBoundsDense;
01276         m_mdInitObjLowerBoundsDense = NULL;
01277 
01278         if (m_mdInitObjUpperBoundsDense != NULL) 
01279                 delete[] m_mdInitObjUpperBoundsDense;
01280         m_mdInitObjUpperBoundsDense = NULL;
01281 
01282         if (m_mdInitConValuesDense != NULL) 
01283                 delete[] m_mdInitConValuesDense;
01284         m_mdInitConValuesDense = NULL;
01285 
01286         if (m_mdInitDualVarLowerBoundsDense != NULL) 
01287                 delete[] m_mdInitDualVarLowerBoundsDense;
01288         m_mdInitDualVarLowerBoundsDense = NULL;
01289 
01290         if (m_mdInitDualVarUpperBoundsDense != NULL) 
01291                 delete[] m_mdInitDualVarUpperBoundsDense;
01292         m_mdInitDualVarUpperBoundsDense = NULL;
01293 }//end OSOption destructor
01294 
01295 
01296 
01297 
01298 /****************************************************************
01299  * get() methods
01300  ****************************************************************/
01301 
01302 /*********************************** 
01303  * get() methods that return strings
01304  ***********************************/
01305 
01309 std::string  OSOption::getFileName()
01310 {       if (this->optionHeader != NULL) 
01311                 return this->optionHeader->name;
01312 
01313         return "";
01314 }//getFileName
01315 
01319 std::string  OSOption::getFileSource()
01320 {       if (this->optionHeader != NULL) 
01321                 return this->optionHeader->source;
01322 
01323         return "";
01324 }//getFileSource
01325 
01329 std::string  OSOption::getFileDescription()
01330 {       if (this->optionHeader != NULL) 
01331                 return this->optionHeader->description;
01332 
01333         return "";
01334 }//getFileDescription
01335 
01339 std::string  OSOption::getFileCreator()
01340 {       if (this->optionHeader != NULL) 
01341                 return this->optionHeader->fileCreator;
01342 
01343         return "";
01344 }//getFileCreator
01345 
01349 std::string  OSOption::getFileLicence()
01350 {       if (this->optionHeader != NULL) 
01351                 return this->optionHeader->licence;
01352 
01353         return "";
01354 }//getFileLicence
01355 
01356 
01360 std::string  OSOption::getServiceURI()
01361 {       if (this->general != NULL) 
01362                 return this->general->serviceURI;
01363 
01364         return "";
01365 }//getServiceURI
01366 
01370 std::string  OSOption::getServiceName()
01371 {       if (this->general != NULL) 
01372                 return this->general->serviceName;
01373 
01374         return "";
01375 }//getServiceName
01376 
01380 std::string  OSOption::getInstanceName()
01381 {       if (this->general != NULL) 
01382                 return this->general->instanceName;
01383 
01384         return "";
01385 }//getInstanceName
01386 
01390 std::string  OSOption::getInstanceLocation()
01391 {       if (this->general != NULL) 
01392                 if (this->general->instanceLocation != NULL)
01393                         return this->general->instanceLocation->value;
01394 
01395         return "";
01396 }//getInstanceLocation
01397 
01401 std::string  OSOption::getInstanceLocationType()
01402 {       if (this->general != NULL) 
01403                 if (this->general->instanceLocation != NULL)
01404                         return this->general->instanceLocation->locationType;
01405 
01406         return "";
01407 }//getLocationType
01408 
01412 std::string  OSOption::getJobID()
01413 {       if (this->general != NULL) 
01414                 return this->general->jobID;
01415 
01416         return "";
01417 }//getJobID
01418 
01422 std::string  OSOption::getSolverToInvoke()
01423 {       if (this->general != NULL) 
01424                 return this->general->solverToInvoke;
01425 
01426         return "";
01427 }//getSolverToInvoke
01428 
01432 std::string  OSOption::getLicense()
01433 {       if (this->general != NULL) 
01434                 return this->general->license;
01435 
01436         return "";
01437 }//getLicense
01438 
01442 std::string  OSOption::getUserName()
01443 {       if (this->general != NULL) 
01444                 return this->general->userName;
01445 
01446         return "";
01447 }//getUserName
01448 
01452 std::string  OSOption::getPassword()
01453 {       if (this->general != NULL) 
01454                 return this->general->password;
01455 
01456         return "";
01457 }//getPassword
01458 
01462 std::string  OSOption::getContact()
01463 {       if (this->general != NULL) 
01464                 if (this->general->contact != NULL)
01465                         return this->general->contact->value;
01466 
01467         return "";
01468 }//getContact
01469 
01473 std::string  OSOption::getContactTransportType()
01474 {       if (this->general != NULL) 
01475                 if (this->general->contact != NULL)
01476                         return this->general->contact->transportType;
01477 
01478         return "";
01479 }//getContactTransportType
01480 
01484 std::string  OSOption::getMinDiskSpaceUnit()
01485 {       if (this->system != NULL) 
01486                 if (this->system->minDiskSpace != NULL)
01487                         return this->system->minDiskSpace->unit;
01488 
01489         return "";
01490 }//getMinDiskSpaceUnit
01491 
01495 std::string  OSOption::getMinDiskSpaceDescription()
01496 {       if (this->system != NULL) 
01497                 if (this->system->minDiskSpace != NULL)
01498                         return this->system->minDiskSpace->description;
01499 
01500         return "";
01501 }//getMinDiskSpaceDescription
01502 
01506 std::string  OSOption::getMinMemoryUnit()
01507 {       if (this->system != NULL) 
01508                 if (this->system->minMemorySize != NULL)
01509                         return this->system->minMemorySize->unit;
01510 
01511         return "";
01512 }//getMinMemory
01513 
01517 std::string  OSOption::getMinMemoryDescription()
01518 {       if (this->system != NULL) 
01519                 if (this->system->minMemorySize != NULL)
01520                         return this->system->minMemorySize->description;
01521 
01522         return "";
01523 }//getMinMemoryDescription
01524 
01528 std::string  OSOption::getMinCPUSpeedUnit()
01529 {       if (this->system != NULL) 
01530                 if (this->system->minCPUSpeed != NULL)
01531                         return this->system->minCPUSpeed->unit;
01532 
01533         return "";
01534 }//getMinCPUSpeed
01535 
01539 std::string  OSOption::getMinCPUSpeedDescription()
01540 {       if (this->system != NULL) 
01541                 if (this->system->minCPUSpeed != NULL)
01542                         return this->system->minCPUSpeed->description;
01543 
01544         return "";
01545 }//getMinCPUSpeedDescription
01546 
01550 std::string  OSOption::getMinCPUNumberDescription()
01551 {       if (this->system != NULL) 
01552                 if (this->system->minCPUNumber != NULL)
01553                         return this->system->minCPUNumber->description;
01554 
01555         return "";
01556 }//getMinCPUNumberDescription
01557 
01561 std::string  OSOption::getServiceType()
01562 {       if (this->service != NULL) 
01563                 return this->service->type;
01564 
01565         return "";
01566 }//getServiceType
01567 
01571 std::string  OSOption::getMaxTimeUnit()
01572 {       if (this->job != NULL) 
01573                 if (this->job->maxTime != NULL)
01574                         return this->job->maxTime->unit;
01575 
01576         return "";
01577 }//getMaxTimeUnit
01578 
01582 std::string  OSOption::getRequestedStartTime()
01583 {       if (this->job != NULL) 
01584                 return this->job->requestedStartTime;
01585 
01586         return "";
01587 }//getRequestedStartTime
01588 
01595 std::string  OSOption::getOptionStr(std::string optionName)
01596 {       if (optionName == "serviceURI") 
01597                 return this->getServiceURI();
01598 
01599         if (optionName == "serviceName") 
01600                 return this->getServiceName();
01601 
01602         if (optionName == "instanceName") 
01603                 return this->getInstanceName();
01604 
01605         if (optionName == "instanceLocation") 
01606                 return this->getInstanceLocation();
01607 
01608         if (optionName == "instanceLocationType") 
01609                 return this->getInstanceLocationType();
01610 
01611         if (optionName == "jobID") 
01612                 return this->getJobID();
01613 
01614         if (optionName == "solverToInvoke") 
01615                 return this->getSolverToInvoke();
01616 
01617         if (optionName == "license") 
01618                 return this->getLicense();
01619 
01620         if (optionName == "userName") 
01621                 return this->getUserName();
01622 
01623         if (optionName == "password") 
01624                 return this->getPassword();
01625 
01626         if (optionName == "contact") 
01627                 return this->getContact();
01628 
01629         if (optionName == "contactTransportType") 
01630                 return this->getContactTransportType();
01631 
01632         if (optionName == "minDiskSpaceUnit") 
01633                 return this->getMinDiskSpaceUnit();
01634 
01635         if (optionName == "minMemoryUnit") 
01636                 return this->getMinMemoryUnit();
01637 
01638         if (optionName == "minCPUSpeedUnit") 
01639                 return this->getMinCPUSpeedUnit();
01640 
01641         if (optionName == "serviceType") 
01642                 return this->getServiceType();
01643 
01644         if (optionName == "maxTimeUnit") 
01645                 return this->getMaxTimeUnit();
01646 
01647         if (optionName == "requestedStartTime") 
01648                 return this->getRequestedStartTime();
01649 
01650         return "";
01651 }//getOptionStr
01652 
01653 /*********************************** 
01654  * get() methods that return doubles
01655  ***********************************/
01656 
01660 double  OSOption::getMinDiskSpace()
01661 {       if (this->system != NULL) 
01662                 if (this->system->minDiskSpace != NULL)
01663                         return this->system->minDiskSpace->value;
01664 
01665         return 0;
01666 }//getMinDiskSpace
01667 
01671 double  OSOption::getMinMemorySize()
01672 {       if (this->system != NULL) 
01673                 if (this->system->minMemorySize != NULL)
01674                         return this->system->minMemorySize->value;
01675 
01676         return 0;
01677 }//getMinMemorySize
01678 
01682 double  OSOption::getMinCPUSpeed()
01683 {       if (this->system != NULL) 
01684                 if (this->system->minCPUSpeed != NULL)
01685                         return this->system->minCPUSpeed->value;
01686 
01687         return 0;
01688 }//getMinCPUSpeed
01689 
01693 double  OSOption::getMaxTime()
01694 {       if (this->job != NULL) 
01695                 if (this->job->maxTime != NULL)
01696                         return job->maxTime->value;
01697 
01698         return 0;
01699 }//getMaxTime
01700 
01707 double  OSOption::getOptionDbl(std::string optionName)
01708 {       if (optionName == "minDiskSpace") 
01709                 return this->getMinDiskSpace();
01710 
01711         if (optionName == "minMemory") 
01712                 return this->getMinMemorySize();
01713 
01714         if (optionName == "minCPUSpeed") 
01715                 return this->getMinCPUSpeed();
01716 
01717         if (optionName == "maxTime") 
01718                 return this->getMaxTime();
01719 
01720         return 0;
01721 }//getOptionDbl
01722 
01730 int  OSOption::getMinCPUNumber()
01731 {       if (this->system != NULL) 
01732                 return this->system->minCPUNumber->value;
01733 
01734         return 0;
01735 }//getMinCPUNumber
01736 
01740 int  OSOption::getNumberOfOtherGeneralOptions()
01741 {       if (this->general != NULL) 
01742                 if (this->general->otherOptions != NULL) 
01743                         return this->general->otherOptions->numberOfOtherOptions;
01744 
01745         return 0;
01746 }//getNumberOfOtherGeneralOptions
01747 
01751 int  OSOption::getNumberOfOtherSystemOptions()
01752 {       if (this->system != NULL) 
01753                 if (this->system->otherOptions != NULL) 
01754                         return this->system->otherOptions->numberOfOtherOptions;
01755 
01756         return 0;
01757 }//getNumberOfOtherSystemOptions
01758 
01762 int  OSOption::getNumberOfOtherServiceOptions()
01763 {       if (this->service != NULL) 
01764                 if (this->service->otherOptions != NULL) 
01765                         return this->service->otherOptions->numberOfOtherOptions;
01766 
01767         return 0;
01768 }//getNumberOfOtherServiceOptions
01769 
01773 int  OSOption::getNumberOfOtherJobOptions()
01774 {       if (this->job != NULL) 
01775                 if (this->job->otherOptions != NULL) 
01776                         return this->job->otherOptions->numberOfOtherOptions;
01777 
01778         return 0;
01779 }//getNumberOfOtherJobOptions
01780 
01784 int  OSOption::getNumberOfJobDependencies()
01785 {       if (this->job != NULL) 
01786                 if (this->job->dependencies != NULL) 
01787                         return this->job->dependencies->numberOfJobIDs;
01788 
01789         return 0;
01790 }//getNumberOfJobDependencies
01791 
01795 int  OSOption::getNumberOfRequiredDirectories()
01796 {       if (this->job != NULL) 
01797                 if (this->job->requiredDirectories != NULL) 
01798                         return this->job->requiredDirectories->numberOfPaths;
01799 
01800         return 0;
01801 }//getNumberOfRequiredDirectories
01802 
01806 int  OSOption::getNumberOfRequiredFiles()
01807 {       if (this->job != NULL) 
01808                 if (this->job->requiredFiles != NULL) 
01809                         return this->job->requiredFiles->numberOfPaths;
01810 
01811         return 0;
01812 }//getNumberOfRequiredFiles
01813 
01817 int  OSOption::getNumberOfDirectoriesToMake()
01818 {       if (this->job != NULL) 
01819                 if (this->job->directoriesToMake != NULL) 
01820                         return this->job->directoriesToMake->numberOfPaths;
01821 
01822         return 0;
01823 }//getNumberOfDirectoriesToMake
01824 
01828 int  OSOption::getNumberOfFilesToMake()
01829 {       if (this->job != NULL) 
01830                 if (this->job->filesToMake != NULL) 
01831                         return this->job->filesToMake->numberOfPaths;
01832 
01833         return 0;
01834 }//getNumberOfFilesToMake
01835 
01839 int  OSOption::getNumberOfInputDirectoriesToMove()
01840 {       if (this->job != NULL) 
01841                 if (this->job->inputDirectoriesToMove != NULL) 
01842                         return this->job->inputDirectoriesToMove->numberOfPathPairs;
01843 
01844         return 0;
01845 }//getNumberOfInputDirectoriesToMove
01846 
01850 int  OSOption::getNumberOfInputFilesToMove()
01851 {       if (this->job != NULL) 
01852                 if (this->job->inputFilesToMove != NULL) 
01853                         return this->job->inputFilesToMove->numberOfPathPairs;
01854 
01855         return 0;
01856 }//getNumberOfInputFilesToMove
01857 
01861 int  OSOption::getNumberOfOutputDirectoriesToMove()
01862 {       if (this->job != NULL) 
01863                 if (this->job->outputDirectoriesToMove != NULL) 
01864                         return this->job->outputDirectoriesToMove->numberOfPathPairs;
01865 
01866         return 0;
01867 }//getNumberOfOutputDirectoriesToMove
01868 
01872 int  OSOption::getNumberOfOutputFilesToMove()
01873 {       if (this->job != NULL) 
01874                 if (this->job->outputFilesToMove != NULL) 
01875                         return this->job->outputFilesToMove->numberOfPathPairs;
01876 
01877         return 0;
01878 }//getNumberOfOutputFilesToMove
01879 
01883 int  OSOption::getNumberOfFilesToDelete()
01884 {       if (this->job != NULL) 
01885                 if (this->job->filesToDelete != NULL) 
01886                         return this->job->filesToDelete->numberOfPaths;
01887 
01888         return 0;
01889 }//getNumberOfFilesToDelete
01890 
01894 int  OSOption::getNumberOfDirectoriesToDelete()
01895 {       if (this->job != NULL) 
01896                 if (this->job->directoriesToDelete != NULL) 
01897                         return this->job->directoriesToDelete->numberOfPaths;
01898 
01899         return 0;
01900 }//getNumberOfDirectoriesToDelete
01901 
01905 int  OSOption::getNumberOfProcessesToKill()
01906 {       if (this->job != NULL) 
01907                 if (this->job->processesToKill != NULL) 
01908                         return this->job->processesToKill->numberOfProcesses;
01909 
01910         return 0;
01911 }//getNumberOfProcessesToKill
01912 
01916 int  OSOption::getNumberOfVariables()
01917 {       if (this->optimization != NULL) 
01918                 return this->optimization->numberOfVariables;
01919 
01920         return -1;
01921 }//getNumberOfVariables
01922 
01926 int  OSOption::getNumberOfObjectives()
01927 {       if (this->optimization != NULL) 
01928                 return this->optimization->numberOfObjectives;
01929 
01930         return -1;
01931 }//getNumberOfObjectives
01932 
01936 int  OSOption::getNumberOfConstraints()
01937 {       if (this->optimization != NULL) 
01938                 return this->optimization->numberOfConstraints;
01939 
01940         return -1;
01941 }//getNumberOfConstraints
01942 
01943 
01947 int OSOption::getNumberOfInitVarValues()
01948 {       
01949         if (this->optimization != NULL) 
01950         {       
01951                 if (this->optimization->variables != NULL) 
01952                 {       
01953                         if (this->optimization->variables->initialVariableValues != NULL) 
01954                         {       
01955                                 return this->optimization->variables->initialVariableValues->numberOfVar;
01956                         }
01957                 }
01958         }
01959         return -1;
01960 }//getNumberOfInitVarValues
01961 
01965 int OSOption::getNumberOfInitVarValuesString()
01966 {       if (this->optimization != NULL) 
01967                 if (this->optimization->variables != NULL) 
01968                         if (this->optimization->variables->initialVariableValuesString != NULL) 
01969                                 return this->optimization->variables->initialVariableValuesString->numberOfVar;
01970         return -1;
01971 }//getNumberOfInitVarValuesString
01972 
01973 
01977 int OSOption::getNumberOfIntegerVariableBranchingWeights()
01978 {       if (this->optimization != NULL) 
01979                 if (this->optimization->variables != NULL) 
01980                         if (this->optimization->variables->integerVariableBranchingWeights != NULL) 
01981                                 return this->optimization->variables->integerVariableBranchingWeights->numberOfVar;
01982         return -1;
01983 }//getNumberOfIntegerBranchingWeights
01984 
01988 int OSOption::getNumberOfSOS()
01989 {       if (this->optimization != NULL) 
01990                 if (this->optimization->variables != NULL) 
01991                         if (this->optimization->variables->sosVariableBranchingWeights != NULL) 
01992                                 return this->optimization->variables->sosVariableBranchingWeights->numberOfSOS;
01993         return -1;
01994 }//getNumberOfSOS
01995 
01999 int OSOption::getNumberOfSOSVarBranchingWeights(int iSOS)
02000 {       if (this->optimization != NULL) 
02001                 if (this->optimization->variables != NULL) 
02002                         if (this->optimization->variables->sosVariableBranchingWeights != NULL) 
02003                         {       if (iSOS >= 0 && iSOS < this->optimization->variables->sosVariableBranchingWeights->numberOfSOS)
02004                                         if (this->optimization->variables->sosVariableBranchingWeights->sos[iSOS] != NULL) 
02005                                                 return this->optimization->variables->sosVariableBranchingWeights->sos[iSOS]->numberOfVar;
02006                         }
02007         return -1;
02008 }//getNumberOfSOSVarBranchingWeights
02009 
02013 int OSOption::getNumberOfOtherVariableOptions()
02014 {       if (this->optimization != NULL)
02015                 if (this->optimization->variables != NULL)
02016                         return this->optimization->variables->numberOfOtherVariableOptions;
02017 
02018         return 0;
02019 }//getNumberOfOtherVariableOptions
02020 
02024 int OSOption::getNumberOfInitObjValues()
02025 {       if (this->optimization != NULL) 
02026                 if (this->optimization->objectives != NULL) 
02027                         if (this->optimization->objectives->initialObjectiveValues != NULL) 
02028                                 return this->optimization->objectives->initialObjectiveValues->numberOfObj;
02029 
02030 return -1;
02031 }//getNumberOfInitObjValues
02032 
02036 int OSOption::getNumberOfInitObjBounds()
02037 {       if (this->optimization != NULL) 
02038                 if (this->optimization->objectives != NULL) 
02039                         if (this->optimization->objectives->initialObjectiveBounds != NULL) 
02040                                 return this->optimization->objectives->initialObjectiveBounds->numberOfObj;
02041         return -1;
02042 }//getNumberOfInitObjBounds
02043 
02047 int OSOption::getNumberOfOtherObjectiveOptions()
02048 {       if (this->optimization != NULL)
02049                 if (this->optimization->objectives != NULL)
02050                         return this->optimization->objectives->numberOfOtherObjectiveOptions;
02051         return 0;
02052 }//getNumberOfOtherObjectiveOptions
02053 
02057 int OSOption::getNumberOfInitConValues()
02058 {       if (this->optimization != NULL) 
02059                 if (this->optimization->constraints != NULL) 
02060                         if (this->optimization->constraints->initialConstraintValues != NULL) 
02061                                 return this->optimization->constraints->initialConstraintValues->numberOfCon;
02062         return -1;
02063 }//getNumberOfInitConValues
02064 
02068 int OSOption::getNumberOfInitDualVarValues()
02069 {       if (this->optimization != NULL) 
02070                 if (this->optimization->constraints != NULL) 
02071                         if (this->optimization->constraints->initialDualValues != NULL) 
02072                                 return this->optimization->constraints->initialDualValues->numberOfCon;
02073 
02074         return -1;
02075 }//getNumberOfInitDualVarValues
02076 
02080 int OSOption::getNumberOfOtherConstraintOptions()
02081 {       if (this->optimization != NULL)
02082                 if (this->optimization->constraints != NULL)
02083                         return this->optimization->constraints->numberOfOtherConstraintOptions;
02084 
02085         return -1;
02086 }//getNumberOfOtherConstraintOptions
02087 
02091 int OSOption::getNumberOfSolverOptions()
02092 {       if (this->optimization != NULL) 
02093                 if (this->optimization->solverOptions != NULL) 
02094                         return this->optimization->solverOptions->numberOfSolverOptions;
02095                 
02096         return -1;
02097 }//getNumberOfSolverOptions
02098 
02105 int  OSOption::getOptionInt(std::string optionName)
02106 {       if (optionName == "minCPUNumber")
02107                 return this->getMinCPUNumber();
02108 
02109         if (optionName == "numberOfOtherGeneralOptions")
02110                 return this->getNumberOfOtherGeneralOptions();
02111 
02112         if (optionName == "numberOfOtherSystemOptions")
02113                 return this->getNumberOfOtherSystemOptions();
02114 
02115         if (optionName == "numberOfOtherServiceOptions")
02116                 return this->getNumberOfOtherServiceOptions();
02117 
02118         if (optionName == "numberOfOtherJobOptions")
02119                 return this->getNumberOfOtherJobOptions();
02120 
02121         if (optionName == "numberOfJobDependencies")
02122                 return this->getNumberOfJobDependencies();
02123 
02124         if (optionName == "numberOfRequiredDirectories")
02125                 return this->getNumberOfRequiredDirectories();
02126 
02127         if (optionName == "numberOfRequiredFiles")
02128                 return this->getNumberOfRequiredFiles();
02129 
02130         if (optionName == "numberOfDirectoriesToMake")
02131                 return this->getNumberOfDirectoriesToMake();
02132 
02133         if (optionName == "numberOfFilesToMake")
02134                 return this->getNumberOfFilesToMake();
02135 
02136         if (optionName == "numberOfInputDirectoriesToMove")
02137                 return this->getNumberOfInputDirectoriesToMove();
02138 
02139         if (optionName == "numberOfInputFilesToMove")
02140                 return this->getNumberOfInputFilesToMove();
02141 
02142         if (optionName == "numberOfOutputDirectoriesToMove")
02143                 return this->getNumberOfOutputDirectoriesToMove();
02144 
02145         if (optionName == "numberOfOutputFilesToMove")
02146                 return this->getNumberOfOutputFilesToMove();
02147 
02148         if (optionName == "numberOfFilesToDelete")
02149                 return this->getNumberOfFilesToDelete();
02150 
02151         if (optionName == "numberOfDirectoriesToDelete")
02152                 return this->getNumberOfDirectoriesToDelete();
02153 
02154         if (optionName == "numberOfProcessesToKill")
02155                 return this->getNumberOfProcessesToKill();
02156 
02157         if (optionName == "numberOfVariables")
02158                 return this->getNumberOfVariables();
02159 
02160         if (optionName == "numberOfObjectives")
02161                 return this->getNumberOfObjectives();
02162 
02163         if (optionName == "numberOfConstraints")
02164                 return this->getNumberOfConstraints();
02165 
02166         if (optionName == "numberOfInitVarValues")
02167                 return this->getNumberOfInitVarValues();
02168 
02169         if (optionName == "numberOfInitVarValuesString")
02170                 return this->getNumberOfInitVarValuesString();
02171 
02172         if (optionName == "numberOfIntegerVariableBranchingWeights")
02173                 return this->getNumberOfIntegerVariableBranchingWeights();
02174 
02175         if (optionName == "numberOfSOS")
02176                 return this->getNumberOfSOS();
02177 
02178         if (optionName == "numberOfOtherVariableOptions")
02179                 return this->getNumberOfOtherVariableOptions();
02180 
02181         if (optionName == "numberOfInitObjValues")
02182                 return this->getNumberOfInitObjValues();
02183 
02184         if (optionName == "numberOfInitObjBounds")
02185                 return this->getNumberOfInitObjBounds();
02186 
02187         if (optionName == "numberOfOtherObjectiveOptions")
02188                 return this->getNumberOfOtherObjectiveOptions();
02189 
02190         if (optionName == "numberOfInitConValues")
02191                 return this->getNumberOfInitConValues();
02192 
02193         if (optionName == "numberOfInitDualVarValues")
02194                 return this->getNumberOfInitDualVarValues();
02195 
02196         if (optionName == "numberOfOtherConstraintOptions")
02197                 return this->getNumberOfOtherConstraintOptions();
02198 
02199         if (optionName == "numberOfSolverOptions")
02200                 return this->getNumberOfSolverOptions();
02201 
02202         return -1;
02203 }//getOptionInt
02204 
02205 
02206 /**************************************************** 
02207  * get() methods that return arrays of various kinds
02208  ****************************************************/
02209 
02213 OtherOption** OSOption::getOtherGeneralOptions()
02214 {       if (this->general != NULL) 
02215         {       if (this->general->otherOptions != NULL)
02216                         return this->general->otherOptions->other;
02217         }
02218         return NULL;
02219 }//getOtherGeneralOptions
02220 
02224 OtherOption** OSOption::getOtherSystemOptions()
02225 {       if (this->system != NULL) 
02226         {       if (this->system->otherOptions != NULL)
02227                         return this->system->otherOptions->other;
02228         }
02229         return NULL;
02230 }//getOtherSystemOptions
02231 
02235 OtherOption** OSOption::getOtherServiceOptions()
02236 {       if (this->service != NULL) 
02237         {       if (this->service->otherOptions != NULL)
02238                         return this->service->otherOptions->other;
02239         }
02240         return NULL;
02241 }//getOtherServiceOptions
02242 
02246 OtherOption** OSOption::getOtherJobOptions()
02247 {       if (this->job != NULL) 
02248         {       if (this->job->otherOptions != NULL)
02249                         return this->job->otherOptions->other;
02250         }
02251         return NULL;
02252 }//getOtherJobOptions
02253 
02260 OtherOption** OSOption::getOtherOptions(std::string category)
02261 {       if (category == "general")
02262                 return this->getOtherGeneralOptions();
02263 
02264         if (category == "system")
02265                 return this->getOtherSystemOptions();
02266 
02267         if (category == "service")
02268                 return this->getOtherServiceOptions();
02269 
02270         if (category == "job")
02271                 return this->getOtherJobOptions();
02272         
02273         return NULL;
02274 }//getOtherOptions
02275 
02279 OtherOption** OSOption::getAllOtherOptions()
02280 {       OtherOption** optionVector = NULL;
02281         int prev_options[4];
02282         int num_options[4];
02283         int num_opt;
02284         int i;
02285 
02286         for (i = 0; i < 4; i++)
02287         {       prev_options[i] = 0;
02288                 num_options[i] = 0;
02289         }
02290         if (this->general != NULL) 
02291         {       if (this->general->otherOptions != NULL)
02292                 {       num_opt = this->getNumberOfOtherGeneralOptions();
02293                         num_options[0] = num_opt;
02294                 }
02295         }
02296 
02297         if (this->system != NULL) 
02298         {       if (this->system->otherOptions != NULL)
02299                 {       num_opt = this->getNumberOfOtherSystemOptions();
02300                         num_options[1] = num_opt;
02301                 }
02302         }
02303         prev_options[1] = prev_options[0] + num_options[0];
02304 
02305         if (this->service != NULL) 
02306         {       if (this->service->otherOptions != NULL)
02307                 {       num_opt = this->getNumberOfOtherServiceOptions();
02308                         num_options[2] = num_opt;
02309                 }
02310         }
02311         prev_options[2] = prev_options[1] + num_options[1];
02312 
02313         if (this->job != NULL) 
02314         {       if (this->job->otherOptions != NULL)
02315                 {       num_opt = this->getNumberOfOtherJobOptions();
02316                         num_options[3] = num_opt;
02317                 }
02318         }
02319         prev_options[3] = prev_options[2] + num_options[2];
02320 
02321         num_opt = num_options[0] + num_options[1] + num_options[2] + num_options[3];
02322         optionVector = new OtherOption*[num_opt];
02323 
02324         if (num_options[0] > 0)
02325         {       
02326                 for (i = 0; i < num_options[0]; i++)
02327                 {       optionVector[prev_options[0] + i] = this->general->otherOptions->other[i];
02328                 }
02329         }
02330 
02331         if (num_options[1] > 0)
02332         {       for (i = 0; i < num_options[1]; i++)
02333                 {       optionVector[prev_options[1] + i] = this->system->otherOptions->other[i];
02334                 }
02335         }
02336 
02337         if (num_options[2] > 0)
02338         {       for (i = 0; i < num_options[2]; i++)
02339                 {       optionVector[prev_options[2] + i] = this->service->otherOptions->other[i];
02340                 }
02341         }
02342 
02343         if (num_options[3] > 0)
02344         {       for (i = 0; i < num_options[3]; i++)
02345                 {       optionVector[prev_options[3] + i] = this->job->otherOptions->other[i];
02346                 }
02347         }
02348 
02349         return optionVector;
02350 }//getOtherJobOptions
02351 
02355 std::string*  OSOption::getJobDependencies()
02356 {       std::string* dependenciesVector = NULL;
02357         if (this->job != NULL) 
02358         {       if (this->job->dependencies != NULL) 
02359                         dependenciesVector = this->job->dependencies->jobID;                            
02360                 else
02361                         throw ErrorClass("<dependencies> object must be defined before getting the jobIDs");
02362         }
02363         else
02364                 throw ErrorClass("<job> object must be defined before getting the jobIDs");
02365 
02366         return dependenciesVector;
02367 }//getJobDependencies
02368 
02372 std::string*  OSOption::getRequiredDirectories()
02373 {       std::string* pathVector = NULL;
02374         if (this->job != NULL) 
02375         {       if (this->job->requiredDirectories != NULL) 
02376                         pathVector = this->job->requiredDirectories->path;                              
02377                 else
02378                         throw ErrorClass("<requiredDirectories> object must be defined before getting the paths");
02379         }
02380         else
02381                 throw ErrorClass("<job> object must be defined before getting the paths");
02382         return pathVector;
02383 }//getRequiredDirectories
02384 
02388 std::string*  OSOption::getRequiredFiles()
02389 {       std::string* pathVector = NULL;
02390         if (this->job != NULL) 
02391         {       if (this->job->requiredFiles != NULL) 
02392                         pathVector = this->job->requiredFiles->path;                            
02393                 else
02394                         throw ErrorClass("<requiredFiles> object must be defined before getting the paths");
02395         }
02396         else
02397                 throw ErrorClass("<job> object must be defined before getting the paths");
02398         return pathVector;
02399 }//getRequiredFiles
02400 
02404 std::string*  OSOption::getDirectoriesToMake()
02405 {       std::string* pathVector = NULL;
02406         if (this->job != NULL) 
02407         {       if (this->job->directoriesToMake != NULL) 
02408                         pathVector = this->job->directoriesToMake->path;                                
02409                 else
02410                         throw ErrorClass("<directoriesToMake> object must be defined before getting the paths");
02411         }
02412         else
02413                 throw ErrorClass("<job> object must be defined before getting the paths");
02414         return pathVector;
02415 }//getDirectoriesToMake
02416 
02420 std::string*  OSOption::getFilesToMake()
02421 {       std::string* pathVector = NULL;
02422         if (this->job != NULL) 
02423         {       if (this->job->filesToMake != NULL) 
02424                         pathVector = this->job->filesToMake->path;                              
02425                 else
02426                         throw ErrorClass("<filesToMake> object must be defined before getting the paths");
02427         }
02428         else
02429                 throw ErrorClass("<job> object must be defined before getting the paths");
02430         return pathVector;
02431 }//getFilesToMake
02432 
02436 PathPair** OSOption::getInputDirectoriesToMove()
02437 {       PathPair** pathPairVector = NULL;
02438         if (this->job != NULL) 
02439         {       if (this->job->inputDirectoriesToMove != NULL) 
02440                         pathPairVector = this->job->inputDirectoriesToMove->pathPair;                           
02441                 else
02442                         throw ErrorClass("<inputDirectoriesToMove> object must be defined before getting the paths");
02443         }
02444         else
02445                 throw ErrorClass("<job> object must be defined before getting the paths");
02446         return pathPairVector;
02447 }//getInputDirectoriesToMove
02448 
02452 PathPair** OSOption::getInputFilesToMove()
02453 {       PathPair** pathPairVector = NULL;
02454         if (this->job != NULL) 
02455         {       if (this->job->inputFilesToMove != NULL) 
02456                         pathPairVector = this->job->inputFilesToMove->pathPair;                         
02457                 else
02458                         throw ErrorClass("<inputFilesToMove> object must be defined before getting the paths");
02459         }
02460         else
02461                 throw ErrorClass("<job> object must be defined before getting the paths");
02462         return pathPairVector;
02463 }//getInputFilesToMove
02464 
02468 PathPair** OSOption::getOutputFilesToMove()
02469 {       PathPair** pathPairVector = NULL;
02470         if (this->job != NULL) 
02471         {       if (this->job->outputFilesToMove != NULL) 
02472                         pathPairVector = this->job->outputFilesToMove->pathPair;                                
02473                 else
02474                         throw ErrorClass("<outputFilesToMove> object must be defined before getting the paths");
02475         }
02476         else
02477                 throw ErrorClass("<job> object must be defined before getting the paths");
02478         return pathPairVector;
02479 }//getOutputFilesToMove
02480 
02484 PathPair** OSOption::getOutputDirectoriesToMove()
02485 {       PathPair** pathPairVector = NULL;
02486         if (this->job != NULL) 
02487         {       if (this->job->outputDirectoriesToMove != NULL) 
02488                         pathPairVector = this->job->outputDirectoriesToMove->pathPair;                          
02489                 else
02490                         throw ErrorClass("<outputDirectoriesToMove> object must be defined before getting the paths");
02491         }
02492         else
02493                 throw ErrorClass("<job> object must be defined before getting the paths");
02494         return pathPairVector;
02495 }//getOutputDirectoriesToMove
02496 
02500 std::string*  OSOption::getFilesToDelete()
02501 {       std::string* pathVector = NULL;
02502         if (this->job != NULL) 
02503         {       if (this->job->filesToDelete != NULL) 
02504                         pathVector = this->job->filesToDelete->path;                            
02505                 else
02506                         throw ErrorClass("<filesToDelete> object must be defined before getting the paths");
02507         }
02508         else
02509                 throw ErrorClass("<job> object must be defined before getting the paths");
02510         return pathVector;
02511 }//getFilesToDelete
02512 
02516 std::string*  OSOption::getDirectoriesToDelete()
02517 {       std::string* pathVector = NULL;
02518         if (this->job != NULL) 
02519         {       if (this->job->directoriesToDelete != NULL) 
02520                         pathVector = this->job->directoriesToDelete->path;                              
02521                 else
02522                         throw ErrorClass("<directoriesToDelete> object must be defined before getting the paths");
02523         }
02524         else
02525                 throw ErrorClass("<job> object must be defined before getting the paths");
02526         return pathVector;
02527 }//getDirectoriesToDelete
02528 
02532 std::string*  OSOption::getProcessesToKill()
02533 {       std::string* processes = NULL;
02534         if (this->job != NULL) 
02535         {       if (this->job->processesToKill != NULL) 
02536                         processes = this->job->processesToKill->process;
02537                 else
02538                         throw ErrorClass("<processesToKill> object must be defined before getting the processes");
02539         }
02540         else
02541                 throw ErrorClass("<job> object must be defined before getting the processes");
02542         return processes;
02543 }//getProcessesToKill
02544 
02545 
02546 
02551 InitVarValue**  OSOption::getInitVarValuesSparse()
02552 {       InitVarValue**  initVarVector;
02553         if (this->optimization != NULL) 
02554         {       if (this->optimization->variables != NULL) 
02555                 {       if (this->optimization->variables->initialVariableValues != NULL) 
02556                                 initVarVector = this->optimization->variables->initialVariableValues->var;
02557                         else
02558                                 throw ErrorClass("<initialVariableValues> object must be defined before getting the data");
02559                 }
02560                 else
02561                         throw ErrorClass("<variables> object must be defined before getting the data");
02562         }
02563         else
02564                 throw ErrorClass("<optimization> object must be defined before getting the data");
02565         return initVarVector;
02566 }//getInitVarValuesSparse
02567 
02573 double* OSOption::getInitVarValuesDense()
02574 {       try
02575         {       int numberOfVariables;
02576                 numberOfVariables = this->getNumberOfVariables();
02577                 if (numberOfVariables < 0)
02578                         throw ErrorClass("\"numberOfVariables\" must be present to use dense methods");         
02579 
02580                 if (this->optimization != NULL) 
02581                 {       if (this->optimization->variables != NULL) 
02582                         {       if (this->optimization->variables->initialVariableValues != NULL) 
02583                                 {       int i,j,k;
02584                                         int num_var;
02585                                         num_var = this->getNumberOfInitVarValues();
02586 
02587                                         if (m_mdInitVarValuesDense != NULL)
02588                                                 delete [] m_mdInitVarValuesDense;
02589                                         m_mdInitVarValuesDense = new double[numberOfVariables];
02590                                         for (k = 0; k < numberOfVariables; k++) m_mdInitVarValuesDense[k] = OSNAN;
02591 
02592                                         for (i = 0; i < num_var; i++)
02593                                         {       j = this->optimization->variables->initialVariableValues->var[i]->idx;
02594                                                 if (j >= 0 && j < numberOfVariables)                                            
02595                                                         m_mdInitVarValuesDense[j] 
02596                                                           = this->optimization->variables->initialVariableValues->var[i]->value;                                                
02597                                                 else
02598                                                         throw ErrorClass("Variable index out of range");
02599                                         }
02600                                         return m_mdInitVarValuesDense;
02601                                 }
02602                         }
02603                 }                                       
02604         }
02605         catch(const ErrorClass& eclass)
02606         {       throw ErrorClass(eclass.errormsg);
02607         }
02608         return NULL;
02609 }//getInitVarValuesDense
02610 
02617 double* OSOption::getInitVarValuesDense(int numberOfVariables)
02618 {       try
02619         {       if (numberOfVariables < 0)
02620                         throw ErrorClass("\"numberOfVariables\" must be present to use dense methods");         
02621 
02622                 if (this->optimization != NULL) 
02623                 {       if (this->optimization->variables != NULL) 
02624                         {       if (this->optimization->variables->initialVariableValues != NULL) 
02625                                 {       int i,j,k;
02626                                         int num_var;
02627                                         num_var = this->getNumberOfInitVarValues();
02628 
02629                                         if (m_mdInitVarValuesDense != NULL)
02630                                                 delete [] m_mdInitVarValuesDense;
02631                                         m_mdInitVarValuesDense = new double[numberOfVariables];
02632                                         for (k = 0; k < numberOfVariables; k++) m_mdInitVarValuesDense[k] = OSNAN;
02633 
02634                                         for (i = 0; i < num_var; i++)
02635                                         {       j = this->optimization->variables->initialVariableValues->var[i]->idx;
02636                                                 if (j >= 0 && j < numberOfVariables)                                            
02637                                                         m_mdInitVarValuesDense[j] 
02638                                                           = this->optimization->variables->initialVariableValues->var[i]->value;                                                
02639                                                 else
02640                                                         throw ErrorClass("Variable index out of range");
02641                                         }
02642                                         return m_mdInitVarValuesDense;
02643                                 }
02644                         }
02645                 }                                       
02646         }
02647         catch(const ErrorClass& eclass)
02648         {       throw ErrorClass(eclass.errormsg);
02649         }
02650         return NULL;
02651 }//getInitVarValuesDense
02652 
02657 InitVarValueString**  OSOption::getInitVarValuesStringSparse()
02658 {       InitVarValueString** initVarVector;
02659         if (this->optimization != NULL) 
02660         {       if (this->optimization->variables != NULL) 
02661                 {       if (this->optimization->variables->initialVariableValuesString != NULL) 
02662                                 initVarVector = this->optimization->variables->initialVariableValuesString->var;
02663                         else
02664                                 throw ErrorClass("<initialVariableValuesString> object must be defined before getting the data");
02665                 }
02666                 else
02667                         throw ErrorClass("<variables> object must be defined before getting the data");
02668         }
02669         else
02670                 throw ErrorClass("<optimization> object must be defined before getting the data");
02671         return initVarVector;
02672 }//getInitVarValuesStringSparse
02673 
02679 std::string *OSOption::getInitVarValuesStringDense()
02680 {       try
02681         {       int numberOfVariables;
02682                 numberOfVariables = this->getNumberOfVariables();
02683                 if (numberOfVariables < 0)
02684                         throw ErrorClass("\"numberOfVariables\" must be present to use dense methods");         
02685 
02686                 if (this->optimization != NULL) 
02687                 {       if (this->optimization->variables != NULL) 
02688                         {       if (this->optimization->variables->initialVariableValuesString != NULL) 
02689                                 {       int i,j,k;
02690                                         int num_var;
02691                                         num_var = this->getNumberOfInitVarValuesString();
02692 
02693                                         if (m_mdInitVarValuesStringDense != NULL)
02694                                                 delete [] m_mdInitVarValuesStringDense;
02695                                         m_mdInitVarValuesStringDense = new std::string[numberOfVariables];
02696                                         for (k = 0; k < numberOfVariables; k++) m_mdInitVarValuesStringDense[k] = "";
02697                 
02698                                         for (i = 0; i < num_var; i++)
02699                                         {       j = this->optimization->variables->initialVariableValuesString->var[i]->idx;
02700                                                 if (j >= 0 && j < numberOfVariables)
02701                                                         m_mdInitVarValuesStringDense[j] 
02702                                                           = this->optimization->variables->initialVariableValuesString->var[i]->value;
02703                                                 else
02704                                                         throw ErrorClass("Variable index out of range");
02705                                         }
02706                                         return m_mdInitVarValuesStringDense;
02707                                 }
02708                         }
02709                 }                                       
02710         }
02711         catch(const ErrorClass& eclass)
02712         {       throw ErrorClass(eclass.errormsg);
02713         }
02714         return NULL;
02715 }//getInitVarValuesStringDense
02716 
02766 int* OSOption::getVariableInitialBasisStatusDense(int numberOfVariables)
02767 {       try
02768         {       if (numberOfVariables < 0)
02769                         throw ErrorClass("\"numberOfVariables\" must be set to use dense methods");             
02770 
02771                 if (this->optimization == NULL) 
02772                         throw ErrorClass("<optimization> element was never set");               
02773 
02774                 if (this->optimization->variables == NULL) 
02775                         throw ErrorClass("<optimization> <variables> element was never set");           
02776 
02777                 if (this->optimization->variables->initialBasisStatus == NULL) 
02778                         throw ErrorClass("initial basis was never set");
02779 
02780                 int i,j,k;
02781 
02782                 if (m_mdInitBasisStatusDense != NULL)
02783                         delete [] m_mdInitBasisStatusDense;
02784                 m_mdInitBasisStatusDense = new int[numberOfVariables];
02785                 for (k = 0; k < numberOfVariables; k++) m_mdInitBasisStatusDense[k] = ENUM_BASIS_STATUS_unknown;
02786                 
02787                 int num_var;
02788 
02789                 if (this->optimization->variables->initialBasisStatus->basic != NULL)
02790                 {
02791                         num_var = this->optimization->variables->initialBasisStatus->basic->numberOfEl;
02792                         for (i = 0; i < num_var; i++)
02793                         {       j = this->optimization->variables->initialBasisStatus->basic->el[i];
02794                                 if (j >= 0 && j < numberOfVariables)
02795                                         m_mdInitBasisStatusDense[j] = ENUM_BASIS_STATUS_basic;
02796                                 else
02797                                         throw ErrorClass("Variable index out of range");
02798                         }
02799                 }
02800 
02801                 if (this->optimization->variables->initialBasisStatus->atLower != NULL)
02802                 {
02803                         num_var = this->optimization->variables->initialBasisStatus->atLower->numberOfEl;
02804                         for (i = 0; i < num_var; i++)
02805                         {       j = this->optimization->variables->initialBasisStatus->atLower->el[i];
02806                                 if (j >= 0 && j < numberOfVariables)
02807                                         m_mdInitBasisStatusDense[j] = ENUM_BASIS_STATUS_atLower;
02808                                 else
02809                                         throw ErrorClass("Variable index out of range");
02810                         }
02811                 }
02812 
02813                 if (this->optimization->variables->initialBasisStatus->atUpper != NULL)
02814                 {
02815                         num_var = this->optimization->variables->initialBasisStatus->atUpper->numberOfEl;
02816                         for (i = 0; i < num_var; i++)
02817                         {       j = this->optimization->variables->initialBasisStatus->atUpper->el[i];
02818                                 if (j >= 0 && j < numberOfVariables)
02819                                         m_mdInitBasisStatusDense[j] = ENUM_BASIS_STATUS_atUpper;
02820                                 else
02821                                         throw ErrorClass("Variable index out of range");
02822                         }
02823                 }
02824 
02825                 if (this->optimization->variables->initialBasisStatus->isFree != NULL)
02826                 {
02827                         num_var = this->optimization->variables->initialBasisStatus->isFree->numberOfEl;
02828                         for (i = 0; i < num_var; i++)
02829                         {       j = this->optimization->variables->initialBasisStatus->isFree->el[i];
02830                                 if (j >= 0 && j < numberOfVariables)
02831                                         m_mdInitBasisStatusDense[j] = ENUM_BASIS_STATUS_isFree;
02832                                 else
02833                                         throw ErrorClass("Variable index out of range");
02834                         }
02835                 }
02836 
02837                 if (this->optimization->variables->initialBasisStatus->superbasic != NULL)
02838                 {
02839                         num_var = this->optimization->variables->initialBasisStatus->superbasic->numberOfEl;
02840                         for (i = 0; i < num_var; i++)
02841                         {       j = this->optimization->variables->initialBasisStatus->superbasic->el[i];
02842                                 if (j >= 0 && j < numberOfVariables)
02843                                         m_mdInitBasisStatusDense[j] = ENUM_BASIS_STATUS_superbasic;
02844                                 else
02845                                         throw ErrorClass("Variable index out of range");
02846                         }
02847                 }
02848 
02849                 return m_mdInitBasisStatusDense;
02850         }
02851 
02852         catch(const ErrorClass& eclass)
02853         {
02854                 throw ErrorClass(eclass.errormsg);
02855         }
02856         return NULL;
02857 }//getVariableInitialBasisStatusDense
02858 
02859 
02860 int OSOption::getNumberOfInitialBasisElements(int type, int status)
02861 {
02862         if (this->optimization == NULL) 
02863                         throw ErrorClass("<optimization> element was never set");               
02864 
02865         switch (type)
02866         {
02867                 case ENUM_PROBLEM_COMPONENT_variables:
02868                 {
02869                         if (this->optimization->variables == NULL) 
02870                                 throw ErrorClass("<optimization> <variables> element was never set");           
02871 
02872                         if (this->optimization->variables->initialBasisStatus == NULL) 
02873                                 throw ErrorClass("initial basis was never set");
02874 
02875                         return this->optimization->variables->initialBasisStatus->getNumberOfEl(status);
02876                 }
02877                 case ENUM_PROBLEM_COMPONENT_objectives:
02878                 {
02879                         if (this->optimization->objectives == NULL) 
02880                                 throw ErrorClass("<optimization> <objectives> element was never set");          
02881 
02882                         if (this->optimization->objectives->initialBasisStatus == NULL) 
02883                                 throw ErrorClass("initial basis was never set");
02884 
02885                         return this->optimization->objectives->initialBasisStatus->getNumberOfEl(status);
02886                 }
02887                 case ENUM_PROBLEM_COMPONENT_constraints:
02888                 {
02889                         if (this->optimization->constraints == NULL) 
02890                                 throw ErrorClass("<optimization> <constraints> element was never set");         
02891 
02892                         if (this->optimization->constraints->initialBasisStatus == NULL) 
02893                                 throw ErrorClass("initial basis was never set");
02894 
02895                         return this->optimization->constraints->initialBasisStatus->getNumberOfEl(status);
02896                 }
02897                 default:
02898                         throw ErrorClass("target object not implemented in setPathPairs");
02899         }
02900 }//getNumberOfInitialBasisElements
02901 
02902 bool OSOption::getInitialBasisElements(int type, int status, int* elem)
02903 {
02904         if (this->optimization == NULL) 
02905                         throw ErrorClass("<optimization> element was never set");               
02906 
02907         switch (type)
02908         {
02909                 case ENUM_PROBLEM_COMPONENT_variables:
02910                 {
02911                         if (this->optimization->variables == NULL) 
02912                                 throw ErrorClass("<optimization> <variables> element was never set");           
02913 
02914                         if (this->optimization->variables->initialBasisStatus == NULL) 
02915                                 throw ErrorClass("initial basis was never set");
02916 
02917                         return this->optimization->variables->initialBasisStatus->getIntVector(status, elem);
02918                 }
02919                 case ENUM_PROBLEM_COMPONENT_objectives:
02920                 {
02921                         if (this->optimization->objectives == NULL) 
02922                                 throw ErrorClass("<optimization> <objectives> element was never set");          
02923 
02924                         if (this->optimization->objectives->initialBasisStatus == NULL) 
02925                                 throw ErrorClass("initial basis was never set");
02926 
02927                         return this->optimization->objectives->initialBasisStatus->getIntVector(status, elem);
02928                 }
02929                 case ENUM_PROBLEM_COMPONENT_constraints:
02930                 {
02931                         if (this->optimization->constraints == NULL) 
02932                                 throw ErrorClass("<optimization> <constraints> element was never set");         
02933 
02934                         if (this->optimization->constraints->initialBasisStatus == NULL) 
02935                                 throw ErrorClass("initial basis was never set");
02936 
02937                         return this->optimization->constraints->initialBasisStatus->getIntVector(status, elem);
02938                 }
02939                 default:
02940                         throw ErrorClass("target object not implemented in setPathPairs");
02941         }
02942 }//getInitialBasisElements
02943 
02944                         
02945                         
02946 
02951 BranchingWeight**  OSOption::getIntegerVariableBranchingWeightsSparse()
02952 {       BranchingWeight** intVarVector;
02953         if (this->optimization != NULL) 
02954         {       if (this->optimization->variables != NULL) 
02955                 {       if (this->optimization->variables->integerVariableBranchingWeights != NULL)
02956                                 intVarVector = this->optimization->variables->integerVariableBranchingWeights->var;
02957                         else
02958                                 throw ErrorClass("<integerVariableBranchingWeights> object must be defined before getting the data");
02959                 }
02960                 else
02961                         throw ErrorClass("<variables> object must be defined before getting the data");
02962         }
02963         else
02964                 throw ErrorClass("<optimization> object must be defined before getting the data");
02965         return intVarVector;
02966 }//getIntegerVariableBranchingWeightsSparse
02967 
02968 
02974 double* OSOption::getIntegerVariableBranchingWeightsDense()
02975 {       try
02976         {       int numberOfVariables;
02977                 numberOfVariables = this->getNumberOfVariables();
02978                 if (numberOfVariables < 0)
02979                         throw ErrorClass("\"numberOfVariables\" must be present to use dense methods");         
02980 
02981                 if (this->optimization != NULL) 
02982                 {       if (this->optimization->variables != NULL) 
02983                         {       if (this->optimization->variables->integerVariableBranchingWeights != NULL) 
02984                                 {       int i,j,k;
02985                                         int num_var;
02986                                         num_var = this->getNumberOfIntegerVariableBranchingWeights();
02987 
02988                                         if (m_mdIntegerVariableBranchingWeightsDense != NULL)
02989                                                 delete [] m_mdIntegerVariableBranchingWeightsDense;
02990                                         m_mdIntegerVariableBranchingWeightsDense = new double[numberOfVariables];
02991                                         for (k = 0; k < numberOfVariables; k++) m_mdIntegerVariableBranchingWeightsDense[k] = OSNAN;
02992 
02993                                         for (i = 0; i < num_var; i++)
02994                                         {       j = this->optimization->variables->integerVariableBranchingWeights->var[i]->idx;
02995                                                 if (j >= 0 && j < numberOfVariables)                                            
02996                                                         m_mdIntegerVariableBranchingWeightsDense[j] 
02997                                                           = this->optimization->variables->integerVariableBranchingWeights->var[i]->value;                                              
02998                                                 else
02999                                                         throw ErrorClass("Variable index out of range");
03000                                         }
03001                                         return m_mdIntegerVariableBranchingWeightsDense;
03002                                 }
03003                         }
03004                 }                                       
03005         }
03006         catch(const ErrorClass& eclass)
03007         {       throw ErrorClass(eclass.errormsg);
03008         }
03009         return NULL;
03010 }//getIntegerVariableBranchingWeightsDense
03011 
03018 double* OSOption::getIntegerVariableBranchingWeightsDense(int numberOfVariables)
03019 {       try
03020         {       if (numberOfVariables < 0)
03021                         throw ErrorClass("\"numberOfVariables\" must be present to use dense methods");         
03022 
03023                 if (this->optimization != NULL) 
03024                 {       if (this->optimization->variables != NULL) 
03025                         {       if (this->optimization->variables->integerVariableBranchingWeights != NULL) 
03026                                 {       int i,j,k;
03027                                         int num_var;
03028                                         num_var = this->getNumberOfIntegerVariableBranchingWeights();
03029 
03030                                         if (m_mdIntegerVariableBranchingWeightsDense != NULL)
03031                                                 delete [] m_mdIntegerVariableBranchingWeightsDense;
03032                                         m_mdIntegerVariableBranchingWeightsDense = new double[numberOfVariables];
03033                                         for (k = 0; k < numberOfVariables; k++) m_mdIntegerVariableBranchingWeightsDense[k] = OSNAN;
03034 
03035                                         for (i = 0; i < num_var; i++)
03036                                         {       j = this->optimization->variables->integerVariableBranchingWeights->var[i]->idx;
03037                                                 if (j >= 0 && j < numberOfVariables)                                            
03038                                                         m_mdIntegerVariableBranchingWeightsDense[j] 
03039                                                           = this->optimization->variables->integerVariableBranchingWeights->var[i]->value;                                              
03040                                                 else
03041                                                         throw ErrorClass("Variable index out of range");
03042                                         }
03043                                         return m_mdIntegerVariableBranchingWeightsDense;
03044                                 }
03045                         }
03046                 }                                       
03047         }
03048         catch(const ErrorClass& eclass)
03049         {       throw ErrorClass(eclass.errormsg);
03050         }
03051         return NULL;
03052 }//getIntegerVariableBranchingWeightsDense
03053 
03058 SOSWeights**  OSOption::getSOSVariableBranchingWeightsSparse()
03059 {       SOSWeights** sosVarVector;
03060         if (this->optimization != NULL) 
03061         {       if (this->optimization->variables != NULL) 
03062                 {       if (this->optimization->variables->sosVariableBranchingWeights != NULL)
03063                                 sosVarVector = this->optimization->variables->sosVariableBranchingWeights->sos;
03064                         else
03065                                 throw ErrorClass("<sosVariableBranchingWeights> object must be defined before getting the data");
03066                 }
03067                 else
03068                         throw ErrorClass("<variables> object must be defined before getting the data");
03069         }
03070         else
03071                 throw ErrorClass("<optimization> object must be defined before getting the data");
03072         return sosVarVector;
03073 }//getSOSVariableBranchingWeightsSparse
03074 
03075 
03081 std::vector<OtherVariableOption*>  OSOption::getOtherVariableOptions( std::string solver_name)
03082 {       std::vector<OtherVariableOption*> optionsVector;
03083         if (this->optimization != NULL) 
03084         {       if (this->optimization->variables != NULL) 
03085                 {       int i;
03086                         int num_options;
03087                         num_options = this->getNumberOfOtherVariableOptions();
03088                         for(i = 0; i < num_options; i++)
03089                                 if (solver_name == this->optimization->variables->other[ i]->solver)
03090                                         optionsVector.push_back( this->optimization->variables->other[ i]);
03091                 }                                       
03092                 else
03093                         throw ErrorClass("<variables> object must be defined before getting the data");
03094         }
03095         else
03096                 throw ErrorClass("<optimization> object must be defined before getting the data");
03097         return optionsVector;
03098 }//getOtherVariableOptions
03099 
03100 
03105 OtherVariableOption** OSOption::getAllOtherVariableOptions()
03106 {       OtherVariableOption** optionsVector;
03107         if (this->optimization != NULL) 
03108         {       if (this->optimization->variables != NULL) 
03109                         optionsVector = this->optimization->variables->other;
03110                 else
03111                         throw ErrorClass("<variables> object must be defined before getting the data");
03112         }
03113         else
03114                 throw ErrorClass("<optimization> object must be defined before getting the data");
03115         return optionsVector;
03116 }//getAllOtherVariableOptions
03117 
03122 InitObjValue**  OSOption::getInitObjValuesSparse()
03123 {       InitObjValue** initObjVector;
03124         if (this->optimization != NULL) 
03125         {       if (this->optimization->objectives != NULL) 
03126                 {       if (this->optimization->objectives->initialObjectiveValues != NULL) 
03127                                 initObjVector = this->optimization->objectives->initialObjectiveValues->obj;                    
03128                         else
03129                                 throw ErrorClass("<initialObjectiveValues> object must be defined before getting the data");
03130                 }
03131                 else
03132                         throw ErrorClass("<objectives> object must be defined before getting the data");
03133         }
03134         else
03135                 throw ErrorClass("<optimization> object must be defined before getting the data");
03136         return initObjVector;
03137 }//getInitObjValuesSparse
03138 
03144 double* OSOption::getInitObjValuesDense()
03145 {       try
03146         {       int numberOfObjectives;
03147                 numberOfObjectives = this->getNumberOfObjectives();
03148                 if (numberOfObjectives < 0)
03149                         throw ErrorClass("\"numberOfObjectives\" must be present to use dense methods");                
03150 
03151                 if (this->optimization != NULL) 
03152                 {       if (this->optimization->objectives != NULL) 
03153                         {       if (this->optimization->objectives->initialObjectiveValues != NULL) 
03154                                 {       int i,j,k;
03155                                         int num_obj;
03156                                         num_obj = this->getNumberOfInitObjValues();
03157 
03158                                         if (m_mdInitObjValuesDense != NULL)
03159                                                 delete [] m_mdInitObjValuesDense;
03160                                         m_mdInitObjValuesDense = new double[numberOfObjectives];
03161                                         for (k = 0; k < numberOfObjectives; k++) m_mdInitObjValuesDense[k] = OSNAN;
03162         
03163                                         for (i = 0; i < num_obj; i++)
03164                                         {       j = this->optimization->objectives->initialObjectiveValues->obj[i]->idx;
03165                                                 if (j < 0 && -j <= numberOfObjectives)                                          
03166                                                         m_mdInitObjValuesDense[-1-j] 
03167                                                           = this->optimization->objectives->initialObjectiveValues->obj[i]->value;                                              
03168                                                 else
03169                                                 {
03170                                                         throw ErrorClass("Objective index out of range");
03171                                                 }
03172                                         }
03173                                         return m_mdInitObjValuesDense;
03174                                 }
03175                         }
03176                 }                                       
03177         }
03178         catch(const ErrorClass& eclass)
03179         {       throw ErrorClass(eclass.errormsg);
03180         }
03181         return NULL;
03182 }//getInitObjValuesDense
03183 
03190 double* OSOption::getInitObjValuesDense(int numberOfObjectives)
03191 {       try
03192         {       if (numberOfObjectives < 0)
03193                         throw ErrorClass("\"numberOfObjectives\" must be present to use dense methods");                
03194 
03195                 if (this->optimization != NULL) 
03196                 {       if (this->optimization->objectives != NULL) 
03197                         {       if (this->optimization->objectives->initialObjectiveValues != NULL) 
03198                                 {       int i,j,k;
03199                                         int num_obj;
03200                                         num_obj = this->getNumberOfInitObjValues();
03201 
03202                                         if (m_mdInitObjValuesDense != NULL)
03203                                                 delete [] m_mdInitObjValuesDense;
03204                                         m_mdInitObjValuesDense = new double[numberOfObjectives];
03205                                         for (k = 0; k < numberOfObjectives; k++) m_mdInitObjValuesDense[k] = OSNAN;
03206         
03207                                         for (i = 0; i < num_obj; i++)
03208                                         {       j = this->optimization->objectives->initialObjectiveValues->obj[i]->idx;
03209                                                 if (j < 0 && -j <= numberOfObjectives)                                          
03210                                                         m_mdInitObjValuesDense[-1-j] 
03211                                                           = this->optimization->objectives->initialObjectiveValues->obj[i]->value;                                              
03212                                                 else
03213                                                 {
03214                                                         throw ErrorClass("Objective index out of range");
03215                                                 }
03216                                         }
03217                                         return m_mdInitObjValuesDense;
03218                                 }
03219                         }
03220                 }                                       
03221         }
03222         catch(const ErrorClass& eclass)
03223         {       throw ErrorClass(eclass.errormsg);
03224         }
03225         return NULL;
03226 }//getInitObjValuesDense
03227 
03232 InitObjBound**  OSOption::getInitObjBoundsSparse()
03233 {       InitObjBound** initObjBounds;
03234         if (this->optimization != NULL) 
03235         {       if (this->optimization->objectives != NULL) 
03236                 {       if (this->optimization->objectives->initialObjectiveBounds != NULL) 
03237                                 initObjBounds = this->optimization->objectives->initialObjectiveBounds->obj;
03238                         else
03239                                 throw ErrorClass("<initialObjectiveBounds> object must be defined before getting the data");
03240                 }
03241                 else
03242                         throw ErrorClass("<objectives> object must be defined before getting the data");
03243         }
03244         else
03245                 throw ErrorClass("<optimization> object must be defined before getting the data");
03246         return initObjBounds;
03247 }//getInitObjBoundsSparse
03248 
03254 double* OSOption::getInitObjLowerBoundsDense()
03255 {       try
03256         {       int numberOfObjectives;
03257                 numberOfObjectives = this->getNumberOfObjectives();
03258                 if (numberOfObjectives < 0)
03259                         throw ErrorClass("\"numberOfObjectives\" must be present to use dense methods");                
03260 
03261                 if (this->optimization != NULL) 
03262                 {       if (this->optimization->objectives != NULL) 
03263                         {       if (this->optimization->objectives->initialObjectiveBounds != NULL) 
03264                                 {       int i,j,k;
03265                                         int num_obj;
03266                                         num_obj = this->getNumberOfInitObjBounds();
03267 
03268                                         if (m_mdInitObjLowerBoundsDense != NULL)
03269                                                 delete [] m_mdInitObjLowerBoundsDense;
03270                                         m_mdInitObjLowerBoundsDense = new double[numberOfObjectives];
03271                                         for (k = 0; k < numberOfObjectives; k++) m_mdInitObjLowerBoundsDense[k] = OSNAN;
03272 
03273                                         for (i = 0; i < num_obj; i++)
03274                                         {       j = this->optimization->objectives->initialObjectiveBounds->obj[i]->idx;
03275                                                 if (j < 0 && -j <= numberOfObjectives)                                          
03276                                                         m_mdInitObjLowerBoundsDense[-1-j] 
03277                                                           = this->optimization->objectives->initialObjectiveBounds->obj[i]->lbValue;
03278                                                 else
03279                                                 {
03280                                                         throw ErrorClass("Objective index out of range");
03281                                                 }
03282                                         }
03283                                         return m_mdInitObjLowerBoundsDense;
03284                                 }
03285                         }
03286                 }                                       
03287         }
03288         catch(const ErrorClass& eclass)
03289         {       throw ErrorClass(eclass.errormsg);
03290         }
03291         return NULL;
03292 }//getInitObjLowerBoundsDense
03293 
03300 double* OSOption::getInitObjLowerBoundsDense(int numberOfObjectives)
03301 {       try
03302         {       if (numberOfObjectives < 0)
03303                         throw ErrorClass("\"numberOfObjectives\" must be present to use dense methods");                
03304 
03305                 if (this->optimization != NULL) 
03306                 {       if (this->optimization->objectives != NULL) 
03307                         {       if (this->optimization->objectives->initialObjectiveBounds != NULL) 
03308                                 {       int i,j,k;
03309                                         int num_obj;
03310                                         num_obj = this->getNumberOfInitObjBounds();
03311 
03312                                         if (m_mdInitObjLowerBoundsDense != NULL)
03313                                                 delete [] m_mdInitObjLowerBoundsDense;
03314                                         m_mdInitObjLowerBoundsDense = new double[numberOfObjectives];
03315                                         for (k = 0; k < numberOfObjectives; k++) m_mdInitObjLowerBoundsDense[k] = OSNAN;
03316 
03317                                         for (i = 0; i < num_obj; i++)
03318                                         {       j = this->optimization->objectives->initialObjectiveBounds->obj[i]->idx;
03319                                                 if (j < 0 && -j <= numberOfObjectives)                                          
03320                                                         m_mdInitObjLowerBoundsDense[-1-j] 
03321                                                           = this->optimization->objectives->initialObjectiveBounds->obj[i]->lbValue;
03322                                                 else
03323                                                 {
03324                                                         throw ErrorClass("Objective index out of range");
03325                                                 }
03326                                         }
03327                                         return m_mdInitObjLowerBoundsDense;
03328                                 }
03329                         }
03330                 }                                       
03331         }
03332         catch(const ErrorClass& eclass)
03333         {       throw ErrorClass(eclass.errormsg);
03334         }
03335         return NULL;
03336 }//getInitObjLowerBoundsDense
03337 
03343 double* OSOption::getInitObjUpperBoundsDense()
03344 {       try
03345         {       int numberOfObjectives;
03346                 numberOfObjectives = this->getNumberOfObjectives();
03347                 if (numberOfObjectives < 0)
03348                         throw ErrorClass("\"numberOfObjectives\" must be present to use dense methods");                
03349 
03350                 if (this->optimization != NULL) 
03351                 {       if (this->optimization->objectives != NULL) 
03352                         {       if (this->optimization->objectives->initialObjectiveBounds != NULL) 
03353                                 {       int i,j,k;
03354                                         int num_obj;
03355                                         num_obj = this->getNumberOfInitObjBounds();
03356 
03357                                         if (m_mdInitObjUpperBoundsDense != NULL)
03358                                                 delete [] m_mdInitObjUpperBoundsDense;
03359                                         m_mdInitObjUpperBoundsDense = new double[numberOfObjectives];
03360                                         for (k = 0; k < numberOfObjectives; k++) m_mdInitObjUpperBoundsDense[k] = OSNAN;
03361                                         
03362                                         for (i = 0; i < num_obj; i++)
03363                                         {       j = this->optimization->objectives->initialObjectiveBounds->obj[i]->idx;
03364                                                 if (j < 0 && -j <= numberOfObjectives)                                          
03365                                                         m_mdInitObjUpperBoundsDense[-1-j] 
03366                                                           = this->optimization->objectives->initialObjectiveBounds->obj[i]->ubValue;
03367                                                 else
03368                                                 {
03369                                                         throw ErrorClass("Objective index out of range");
03370                                                 }
03371                                         }
03372                                         return m_mdInitObjUpperBoundsDense;
03373                                 }
03374                         }
03375                 }                                       
03376         }
03377         catch(const ErrorClass& eclass)
03378         {       throw ErrorClass(eclass.errormsg);
03379         }
03380         return NULL;
03381 }//getInitObjUpperBoundsDense
03382 
03389 double* OSOption::getInitObjUpperBoundsDense(int numberOfObjectives)
03390 {       try
03391         {       if (numberOfObjectives < 0)
03392                         throw ErrorClass("\"numberOfObjectives\" must be present to use dense methods");                
03393 
03394                 if (this->optimization != NULL) 
03395                 {       if (this->optimization->objectives != NULL) 
03396                         {       if (this->optimization->objectives->initialObjectiveBounds != NULL) 
03397                                 {       int i,j,k;
03398                                         int num_obj;
03399                                         num_obj = this->getNumberOfInitObjBounds();
03400 
03401                                         if (m_mdInitObjUpperBoundsDense != NULL)
03402                                                 delete [] m_mdInitObjUpperBoundsDense;
03403                                         m_mdInitObjUpperBoundsDense = new double[numberOfObjectives];
03404                                         for (k = 0; k < numberOfObjectives; k++) m_mdInitObjUpperBoundsDense[k] = OSNAN;
03405                                         
03406                                         for (i = 0; i < num_obj; i++)
03407                                         {       j = this->optimization->objectives->initialObjectiveBounds->obj[i]->idx;
03408                                                 if (j < 0 && -j <= numberOfObjectives)                                          
03409                                                         m_mdInitObjUpperBoundsDense[-1-j] 
03410                                                           = this->optimization->objectives->initialObjectiveBounds->obj[i]->ubValue;
03411                                                 else
03412                                                 {
03413                                                         throw ErrorClass("Objective index out of range");
03414                                                 }
03415                                         }
03416                                         return m_mdInitObjUpperBoundsDense;
03417                                 }
03418                         }
03419                 }                                       
03420         }
03421         catch(const ErrorClass& eclass)
03422         {       throw ErrorClass(eclass.errormsg);
03423         }
03424         return NULL;
03425 }//getInitObjUpperBoundsDense
03426 
03433 std::string *OSOption::getInitVarValuesStringDense(int numberOfVariables)
03434 {       try
03435         {       if (numberOfVariables < 0)
03436                         throw ErrorClass("\"numberOfVariables\" must be present to use dense methods");         
03437 
03438                 if (this->optimization != NULL) 
03439                 {       if (this->optimization->variables != NULL) 
03440                         {       if (this->optimization->variables->initialVariableValuesString != NULL) 
03441                                 {       int i,j,k;
03442                                         int num_var;
03443                                         num_var = this->getNumberOfInitVarValuesString();
03444 
03445                                         if (m_mdInitVarValuesStringDense != NULL)
03446                                                 delete [] m_mdInitVarValuesStringDense;
03447                                         m_mdInitVarValuesStringDense = new std::string[numberOfVariables];
03448                                         for (k = 0; k < numberOfVariables; k++) m_mdInitVarValuesStringDense[k] = "";
03449                 
03450                                         for (i = 0; i < num_var; i++)
03451                                         {       j = this->optimization->variables->initialVariableValuesString->var[i]->idx;
03452                                                 if (j >= 0 && j < numberOfVariables)
03453                                                         m_mdInitVarValuesStringDense[j] 
03454                                                           = this->optimization->variables->initialVariableValuesString->var[i]->value;
03455                                                 else
03456                                                         throw ErrorClass("Variable index out of range");
03457                                         }
03458                                         return m_mdInitVarValuesStringDense;
03459                                 }
03460                         }
03461                 }                                       
03462         }
03463         catch(const ErrorClass& eclass)
03464         {       throw ErrorClass(eclass.errormsg);
03465         }
03466         return NULL;
03467 }//getInitVarValuesStringDense
03468 
03469 
03476 int* OSOption::getObjectiveInitialBasisStatusDense(int numberOfObjectives)
03477 {       try
03478         {       if (numberOfObjectives < 0)
03479                         throw ErrorClass("\"numberOfObjectives\" must be set to use dense methods");            
03480 
03481                 if (this->optimization == NULL) 
03482                         throw ErrorClass("<optimization> element was never set");               
03483 
03484                 if (this->optimization->objectives == NULL) 
03485                         throw ErrorClass("<optimization> <objectives> element was never set");          
03486 
03487                 if (this->optimization->objectives->initialBasisStatus == NULL) 
03488                         throw ErrorClass("initial basis was never set");
03489 
03490                 int i,j,k;
03491 
03492                 if (m_mdInitBasisStatusDense != NULL)
03493                         delete [] m_mdInitBasisStatusDense;
03494                 m_mdInitBasisStatusDense = new int[numberOfObjectives];
03495                 for (k = 0; k < numberOfObjectives; k++) m_mdInitBasisStatusDense[k] = ENUM_BASIS_STATUS_unknown;
03496                 
03497                 int num_obj;
03498 
03499                 if (this->optimization->objectives->initialBasisStatus->basic != NULL)
03500                 {
03501                         num_obj = this->optimization->objectives->initialBasisStatus->basic->numberOfEl;
03502                         for (i = 0; i < num_obj; i++)
03503                         {       j = this->optimization->objectives->initialBasisStatus->basic->el[i];
03504                                 if (j >= 0 || j < -numberOfObjectives)
03505                                         throw ErrorClass("Objective index out of range");
03506                                 else
03507                                         m_mdInitBasisStatusDense[j] = ENUM_BASIS_STATUS_basic;
03508                         }
03509                 }
03510 
03511                 if (this->optimization->objectives->initialBasisStatus->atLower != NULL)
03512                 {
03513                         num_obj = this->optimization->objectives->initialBasisStatus->atLower->numberOfEl;
03514                         for (i = 0; i < num_obj; i++)
03515                         {       j = this->optimization->objectives->initialBasisStatus->atLower->el[i];
03516                                 if (j >= 0 || j < -numberOfObjectives)
03517                                         throw ErrorClass("Objective index out of range");
03518                                 else
03519                                         m_mdInitBasisStatusDense[j] = ENUM_BASIS_STATUS_atLower;
03520                         }
03521                 }
03522 
03523                 if (this->optimization->objectives->initialBasisStatus->atUpper != NULL)
03524                 {
03525                         num_obj = this->optimization->objectives->initialBasisStatus->atUpper->numberOfEl;
03526                         for (i = 0; i < num_obj; i++)
03527                         {       j = this->optimization->objectives->initialBasisStatus->atUpper->el[i];
03528                                 if (j >= 0 || j < -numberOfObjectives)
03529                                         throw ErrorClass("Objective index out of range");
03530                                 else
03531                                         m_mdInitBasisStatusDense[j] = ENUM_BASIS_STATUS_atUpper;
03532                         }
03533                 }
03534 
03535                 if (this->optimization->objectives->initialBasisStatus->isFree != NULL)
03536                 {
03537                         num_obj = this->optimization->objectives->initialBasisStatus->isFree->numberOfEl;
03538                         for (i = 0; i < num_obj; i++)
03539                         {       j = this->optimization->objectives->initialBasisStatus->isFree->el[i];
03540                                 if (j >= 0 || j < -numberOfObjectives)
03541                                         throw ErrorClass("Objective index out of range");
03542                                 else
03543                                         m_mdInitBasisStatusDense[j] = ENUM_BASIS_STATUS_isFree;
03544                         }
03545                 }
03546 
03547                 if (this->optimization->objectives->initialBasisStatus->superbasic != NULL)
03548                 {
03549                         num_obj = this->optimization->objectives->initialBasisStatus->superbasic->numberOfEl;
03550                         for (i = 0; i < num_obj; i++)
03551                         {       j = this->optimization->objectives->initialBasisStatus->superbasic->el[i];
03552                                 if (j >= 0 || j < -numberOfObjectives)
03553                                         throw ErrorClass("Objective index out of range");
03554                                 else
03555                                         m_mdInitBasisStatusDense[j] = ENUM_BASIS_STATUS_superbasic;
03556                         }
03557                 }
03558 
03559                 return m_mdInitBasisStatusDense;
03560         }
03561 
03562         catch(const ErrorClass& eclass)
03563         {
03564                 throw ErrorClass(eclass.errormsg);
03565         }
03566         return NULL;
03567 }//getVariableInitialBasisStatusDense
03568 
03569 
03570 
03571 
03577 std::vector<OtherObjectiveOption*>  OSOption::getOtherObjectiveOptions( std::string solver_name)
03578 {       std::vector<OtherObjectiveOption*> optionsVector;
03579         if (this->optimization != NULL) 
03580         {       if (this->optimization->variables != NULL) 
03581                 {       int i;
03582                         int num_options;
03583                         num_options = this->getNumberOfOtherObjectiveOptions();
03584                         for(i = 0; i < num_options; i++)
03585                                 if (solver_name == this->optimization->objectives->other[ i]->solver)
03586                                         optionsVector.push_back( this->optimization->objectives->other[ i]);
03587                 }                                       
03588                 else
03589                         throw ErrorClass("<objectives> object must be defined before getting the data");
03590         }
03591         else
03592                 throw ErrorClass("<optimization> object must be defined before getting the data");
03593         return optionsVector;
03594 }//getOtherObjectiveOptions
03595 
03600 OtherObjectiveOption** OSOption::getAllOtherObjectiveOptions()
03601 {       OtherObjectiveOption** optionsVector;
03602         if (this->optimization != NULL) 
03603         {       if (this->optimization->objectives != NULL) 
03604                         optionsVector = this->optimization->objectives->other;
03605                 else
03606                         throw ErrorClass("<objectives> object must be defined before getting the data");
03607         }
03608         else
03609                 throw ErrorClass("<optimization> object must be defined before getting the data");
03610         return optionsVector;
03611 }//getAllOtherObjectiveOptions
03612 
03613 
03618 InitConValue**  OSOption::getInitConValuesSparse()
03619 {       InitConValue** initConVector;
03620         if (this->optimization != NULL) 
03621         {       if (this->optimization->constraints != NULL) 
03622                 {       if (this->optimization->constraints->initialConstraintValues != NULL) 
03623                                 initConVector = this->optimization->constraints->initialConstraintValues->con;                  
03624                         else
03625                                 throw ErrorClass("<initialConstraintValues> object must be defined before getting the data");
03626                 }
03627                 else
03628                         throw ErrorClass("<constraints> object must be defined before getting the data");
03629         }
03630         else
03631                 throw ErrorClass("<optimization> object must be defined before getting the data");
03632         return initConVector;
03633 }//getInitConValuesSparse
03634 
03640 double* OSOption::getInitConValuesDense()
03641 {       try
03642         {       int numberOfConstraints;
03643                 numberOfConstraints = this->getNumberOfConstraints();
03644                 if (numberOfConstraints < 0)
03645                         throw ErrorClass("\"numberOfConstraints\" must be present to use dense methods");               
03646 
03647                 if (this->optimization != NULL) 
03648                 {       if (this->optimization->constraints != NULL) 
03649                         {       if (this->optimization->constraints->initialConstraintValues != NULL) 
03650                                 {       int i,j,k;
03651                                         int num_con;
03652                                         num_con = this->getNumberOfInitConValues();
03653 
03654                                         if (m_mdInitConValuesDense != NULL)
03655                                                 delete [] m_mdInitConValuesDense;
03656                                         m_mdInitConValuesDense = new double[numberOfConstraints];
03657                                         for (k = 0; k < numberOfConstraints; k++) m_mdInitConValuesDense[k] = OSNAN;
03658 
03659                                         for (i = 0; i < num_con; i++)
03660                                         {       j = this->optimization->constraints->initialConstraintValues->con[i]->idx;
03661                                                 if (j >= 0 && j < numberOfConstraints)                                          
03662                                                         m_mdInitConValuesDense[j] 
03663                                                           = this->optimization->constraints->initialConstraintValues->con[i]->value;                                            
03664                                                 else
03665                                                         throw ErrorClass("Constraint index out of range");
03666                                         }
03667                                 return m_mdInitConValuesDense;
03668                                 }
03669                         }
03670                 }                                       
03671         }
03672         catch(const ErrorClass& eclass)
03673         {       throw ErrorClass(eclass.errormsg);
03674         }
03675         return NULL;
03676 }//getInitConValuesDense
03677 
03684 double* OSOption::getInitConValuesDense(int numberOfConstraints)
03685 {       try
03686         {       if (numberOfConstraints < 0)
03687                         throw ErrorClass("\"numberOfConstraints\" must be present to use dense methods");               
03688 
03689                 if (this->optimization != NULL) 
03690                 {       if (this->optimization->constraints != NULL) 
03691                         {       if (this->optimization->constraints->initialConstraintValues != NULL) 
03692                                 {       int i,j,k;
03693                                         int num_con;
03694                                         num_con = this->getNumberOfInitConValues();
03695 
03696                                         if (m_mdInitConValuesDense != NULL)
03697                                                 delete [] m_mdInitConValuesDense;
03698                                         m_mdInitConValuesDense = new double[numberOfConstraints];
03699                                         for (k = 0; k < numberOfConstraints; k++) m_mdInitConValuesDense[k] = OSNAN;
03700 
03701                                         for (i = 0; i < num_con; i++)
03702                                         {       j = this->optimization->constraints->initialConstraintValues->con[i]->idx;
03703                                                 if (j >= 0 && j < numberOfConstraints)                                          
03704                                                         m_mdInitConValuesDense[j] 
03705                                                           = this->optimization->constraints->initialConstraintValues->con[i]->value;                                            
03706                                                 else
03707                                                         throw ErrorClass("Constraint index out of range");
03708                                         }
03709                                 return m_mdInitConValuesDense;
03710                                 }
03711                         }
03712                 }                                       
03713         }
03714         catch(const ErrorClass& eclass)
03715         {       throw ErrorClass(eclass.errormsg);
03716         }
03717         return NULL;
03718 }//getInitConValuesDense
03719 
03724 InitDualVarValue**  OSOption::getInitDualVarValuesSparse()
03725 {       InitDualVarValue** initDualVector;
03726         if (this->optimization != NULL) 
03727         {       if (this->optimization->constraints != NULL) 
03728                 {       if (this->optimization->constraints->initialDualValues != NULL) 
03729                                 initDualVector = this->optimization->constraints->initialDualValues->con;                       
03730                         else
03731                                 throw ErrorClass("<initialDualValues> object must be defined before getting the data");
03732                 }
03733                 else
03734                         throw ErrorClass("<constraints> object must be defined before getting the data");
03735         }
03736         else
03737                 throw ErrorClass("<optimization> object must be defined before getting the data");
03738         return initDualVector;
03739 }//getInitDualVarValuesSparse
03740 
03746 double* OSOption::getInitDualVarLowerBoundsDense()
03747 {       try
03748         {       int numberOfConstraints;
03749                 numberOfConstraints = this->getNumberOfConstraints();
03750                 if (numberOfConstraints < 0)
03751                         throw ErrorClass("\"numberOfConstraints\" must be present to use dense methods");               
03752 
03753                 if (this->optimization != NULL) 
03754                 {       if (this->optimization->constraints != NULL) 
03755                         {       if (this->optimization->constraints->initialDualValues != NULL) 
03756                                 {       int i,j,k;
03757                                         int num_con;
03758                                         num_con = this->getNumberOfInitDualVarValues();
03759 
03760                                         if (m_mdInitDualVarLowerBoundsDense != NULL)
03761                                                 delete [] m_mdInitDualVarLowerBoundsDense;
03762                                         m_mdInitDualVarLowerBoundsDense = new double[numberOfConstraints];
03763                                         for (k = 0; k < numberOfConstraints; k++) m_mdInitDualVarLowerBoundsDense[k] = 0.0;
03764 
03765                                         for (i = 0; i < num_con; i++)
03766                                         {       j = this->optimization->constraints->initialDualValues->con[i]->idx;
03767                                                 if (j >= 0 && j < numberOfConstraints)                                          
03768                                                         m_mdInitDualVarLowerBoundsDense[j] 
03769                                                           = this->optimization->constraints->initialDualValues->con[i]->lbDualValue;                                            
03770                                                 else
03771                                                         throw ErrorClass("Constraint index out of range");
03772                                         }
03773                                         return m_mdInitDualVarLowerBoundsDense;
03774                                 }
03775                         }
03776                 }                                       
03777         }
03778         catch(const ErrorClass& eclass)
03779         {       throw ErrorClass(eclass.errormsg);
03780         }
03781         return NULL;
03782 }//getInitDualVarLowerBoundsDense
03783 
03790 double* OSOption::getInitDualVarLowerBoundsDense(int numberOfConstraints)
03791 {       try
03792         {       if (numberOfConstraints < 0)
03793                         throw ErrorClass("\"numberOfConstraints\" must be present to use dense methods");               
03794 
03795                 if (this->optimization != NULL) 
03796                 {       if (this->optimization->constraints != NULL) 
03797                         {       if (this->optimization->constraints->initialDualValues != NULL) 
03798                                 {       int i,j,k;
03799                                         int num_con;
03800                                         num_con = this->getNumberOfInitDualVarValues();
03801 
03802                                         if (m_mdInitDualVarLowerBoundsDense != NULL)
03803                                                 delete [] m_mdInitDualVarLowerBoundsDense;
03804                                         m_mdInitDualVarLowerBoundsDense = new double[numberOfConstraints];
03805                                         for (k = 0; k < numberOfConstraints; k++) m_mdInitDualVarLowerBoundsDense[k] = 0.0;
03806 
03807                                         for (i = 0; i < num_con; i++)
03808                                         {       j = this->optimization->constraints->initialDualValues->con[i]->idx;
03809                                                 if (j >= 0 && j < numberOfConstraints)                                          
03810                                                         m_mdInitDualVarLowerBoundsDense[j] 
03811                                                           = this->optimization->constraints->initialDualValues->con[i]->lbDualValue;                                            
03812                                                 else
03813                                                         throw ErrorClass("Constraint index out of range");
03814                                         }
03815                                         return m_mdInitDualVarLowerBoundsDense;
03816                                 }
03817                         }
03818                 }                                       
03819         }
03820         catch(const ErrorClass& eclass)
03821         {       throw ErrorClass(eclass.errormsg);
03822         }
03823         return NULL;
03824 }//getInitDualVarLowerBoundsDense
03825 
03831 double* OSOption::getInitDualVarUpperBoundsDense()
03832 {       try
03833         {       int numberOfConstraints;
03834                 numberOfConstraints = this->getNumberOfConstraints();
03835                 if (numberOfConstraints < 0)
03836                         throw ErrorClass("\"numberOfConstraints\" must be present to use dense methods");               
03837 
03838                 if (this->optimization != NULL) 
03839                 {       if (this->optimization->constraints != NULL) 
03840                         {       if (this->optimization->constraints->initialDualValues != NULL) 
03841                                 {       int i,j,k;
03842                                         int num_con;
03843                                         num_con = this->getNumberOfInitDualVarValues();
03844                                         numberOfConstraints = this->getNumberOfConstraints();
03845 
03846                                         if (m_mdInitDualVarUpperBoundsDense != NULL)
03847                                                 delete [] m_mdInitDualVarUpperBoundsDense;
03848                                         m_mdInitDualVarUpperBoundsDense = new double[numberOfConstraints];
03849                                         for (k = 0; k < numberOfConstraints; k++) m_mdInitDualVarUpperBoundsDense[k] = 0.0;
03850 
03851                                         for (i = 0; i < num_con; i++)
03852                                         {       j = this->optimization->constraints->initialDualValues->con[i]->idx;
03853                                                 if (j >= 0 && j < numberOfConstraints)                                          
03854                                                         m_mdInitDualVarUpperBoundsDense[j] 
03855                                                           = this->optimization->constraints->initialDualValues->con[i]->ubDualValue;    
03856                                                 else
03857                                                         throw ErrorClass("Constraint index out of range");
03858                                         }
03859                                         return m_mdInitDualVarUpperBoundsDense;
03860                                 }
03861                         }
03862                 }                                       
03863         }
03864         catch(const ErrorClass& eclass)
03865         {       throw ErrorClass(eclass.errormsg);
03866         }
03867         return NULL;
03868 }//getInitDualVarUpperBoundsDense
03869 
03876 double* OSOption::getInitDualVarUpperBoundsDense(int numberOfConstraints)
03877 {       try
03878         {       if (numberOfConstraints < 0)
03879                         throw ErrorClass("\"numberOfConstraints\" must be present to use dense methods");               
03880 
03881                 if (this->optimization != NULL) 
03882                 {       if (this->optimization->constraints != NULL) 
03883                         {       if (this->optimization->constraints->initialDualValues != NULL) 
03884                                 {       int i,j,k;
03885                                         int num_con;
03886                                         num_con = this->getNumberOfInitDualVarValues();
03887                                         numberOfConstraints = this->getNumberOfConstraints();
03888 
03889                                         if (m_mdInitDualVarUpperBoundsDense != NULL)
03890                                                 delete [] m_mdInitDualVarUpperBoundsDense;
03891                                         m_mdInitDualVarUpperBoundsDense = new double[numberOfConstraints];
03892                                         for (k = 0; k < numberOfConstraints; k++) m_mdInitDualVarUpperBoundsDense[k] = 0.0;
03893 
03894                                         for (i = 0; i < num_con; i++)
03895                                         {       j = this->optimization->constraints->initialDualValues->con[i]->idx;
03896                                                 if (j >= 0 && j < numberOfConstraints)                                          
03897                                                         m_mdInitDualVarUpperBoundsDense[j] 
03898                                                           = this->optimization->constraints->initialDualValues->con[i]->ubDualValue;    
03899                                                 else
03900                                                         throw ErrorClass("Constraint index out of range");
03901                                         }
03902                                         return m_mdInitDualVarUpperBoundsDense;
03903                                 }
03904                         }
03905                 }                                       
03906         }
03907         catch(const ErrorClass& eclass)
03908         {       throw ErrorClass(eclass.errormsg);
03909         }
03910         return NULL;
03911 }//getInitDualVarUpperBoundsDense
03912 
03913 
03920 int* OSOption::getSlackVariableInitialBasisStatusDense(int numberOfConstraints)
03921 {       try
03922         {       if (numberOfConstraints < 0)
03923                         throw ErrorClass("\"numberOfConstraints\" must be set to use dense methods");           
03924 
03925                 if (this->optimization == NULL) 
03926                         throw ErrorClass("<optimization> element was never set");               
03927 
03928                 if (this->optimization->constraints == NULL) 
03929                         throw ErrorClass("<optimization> <constraints> element was never set");         
03930 
03931                 if (this->optimization->constraints->initialBasisStatus == NULL) 
03932                         throw ErrorClass("initial basis was never set");
03933 
03934                 int i,j,k;
03935 
03936                 if (m_mdInitBasisStatusDense != NULL)
03937                         delete [] m_mdInitBasisStatusDense;
03938                 m_mdInitBasisStatusDense = new int[numberOfConstraints];
03939                 for (k = 0; k < numberOfConstraints; k++) m_mdInitBasisStatusDense[k] = ENUM_BASIS_STATUS_unknown;
03940                 
03941                 int num_slack;
03942 
03943                 if (this->optimization->constraints->initialBasisStatus->basic != NULL)
03944                 {
03945                         num_slack = this->optimization->constraints->initialBasisStatus->basic->numberOfEl;
03946                         for (i = 0; i < num_slack; i++)
03947                         {       j = this->optimization->constraints->initialBasisStatus->basic->el[i];
03948                                 if (j >= 0 && j < numberOfConstraints)
03949                                         m_mdInitBasisStatusDense[j] = ENUM_BASIS_STATUS_basic;
03950                                 else
03951                                         throw ErrorClass("Constraint index out of range");
03952                         }
03953                 }
03954 
03955                 if (this->optimization->constraints->initialBasisStatus->atLower != NULL)
03956                 {
03957                         num_slack = this->optimization->constraints->initialBasisStatus->atLower->numberOfEl;
03958                         for (i = 0; i < num_slack; i++)
03959                         {       j = this->optimization->constraints->initialBasisStatus->atLower->el[i];
03960                                 if (j >= 0 && j < numberOfConstraints)
03961                                         m_mdInitBasisStatusDense[j] = ENUM_BASIS_STATUS_atLower;
03962                                 else
03963                                         throw ErrorClass("Constraint index out of range");
03964                         }
03965                 }
03966 
03967                 if (this->optimization->constraints->initialBasisStatus->atUpper != NULL)
03968                 {
03969                         num_slack = this->optimization->constraints->initialBasisStatus->atUpper->numberOfEl;
03970                         for (i = 0; i < num_slack; i++)
03971                         {       j = this->optimization->constraints->initialBasisStatus->atUpper->el[i];
03972                                 if (j >= 0 && j < numberOfConstraints)
03973                                         m_mdInitBasisStatusDense[j] = ENUM_BASIS_STATUS_atUpper;
03974                                 else
03975                                         throw ErrorClass("Constraint index out of range");
03976                         }
03977                 }
03978 
03979                 if (this->optimization->constraints->initialBasisStatus->isFree != NULL)
03980                 {
03981                         num_slack = this->optimization->constraints->initialBasisStatus->isFree->numberOfEl;
03982                         for (i = 0; i < num_slack; i++)
03983                         {       j = this->optimization->constraints->initialBasisStatus->isFree->el[i];
03984                                 if (j >= 0 && j < numberOfConstraints)
03985                                         m_mdInitBasisStatusDense[j] = ENUM_BASIS_STATUS_isFree;
03986                                 else
03987                                         throw ErrorClass("Constraint index out of range");
03988                         }
03989                 }
03990 
03991                 if (this->optimization->constraints->initialBasisStatus->superbasic != NULL)
03992                 {
03993                         num_slack = this->optimization->constraints->initialBasisStatus->superbasic->numberOfEl;
03994                         for (i = 0; i < num_slack; i++)
03995                         {       j = this->optimization->constraints->initialBasisStatus->superbasic->el[i];
03996                                 if (j >= 0 && j < numberOfConstraints)
03997                                         m_mdInitBasisStatusDense[j] = ENUM_BASIS_STATUS_superbasic;
03998                                 else
03999                                         throw ErrorClass("Constraint index out of range");
04000                         }
04001                 }
04002 
04003                 return m_mdInitBasisStatusDense;
04004         }
04005 
04006         catch(const ErrorClass& eclass)
04007         {
04008                 throw ErrorClass(eclass.errormsg);
04009         }
04010         return NULL;
04011 }//getSlackVariableInitialBasisStatusDense
04012 
04013 
04019 std::vector<OtherConstraintOption*>  OSOption::getOtherConstraintOptions( std::string solver_name)
04020 {       std::vector<OtherConstraintOption*> optionsVector;
04021         if (this->optimization != NULL) 
04022         {       if (this->optimization->constraints != NULL) 
04023                 {       int i;
04024                         int num_options;
04025                         num_options = this->getNumberOfOtherConstraintOptions();
04026                         for(i = 0; i < num_options; i++)
04027                                 if (solver_name == this->optimization->constraints->other[ i]->solver)
04028                                         optionsVector.push_back( this->optimization->constraints->other[ i]);
04029                 }                                       
04030                 else
04031                         throw ErrorClass("<constraints> object must be defined before getting the data");
04032         }
04033         else
04034                 throw ErrorClass("<optimization> object must be defined before getting the data");
04035         return optionsVector;
04036 }//getOtherConstraintOptions
04037 
04042 OtherConstraintOption** OSOption::getAllOtherConstraintOptions()
04043 {       OtherConstraintOption** optionsVector;
04044         if (this->optimization != NULL) 
04045         {       if (this->optimization->constraints != NULL) 
04046                         optionsVector = this->optimization->constraints->other;
04047                 else
04048                         throw ErrorClass("<constraints> object must be defined before getting the data");
04049         }
04050         else
04051                 throw ErrorClass("<optimization> object must be defined before getting the data");
04052         return optionsVector;
04053 }//getAllOtherConstraintOptions
04054 
04055 
04061 std::vector<SolverOption*>  OSOption::getSolverOptions( std::string solver_name)
04062 {       std::vector<SolverOption*> optionsVector;
04063         if (this->optimization != NULL) 
04064         {       if (this->optimization->solverOptions != NULL) 
04065                 {       int i;
04066                         int num_options;
04067                         num_options = this->getNumberOfSolverOptions();
04068                         for(i = 0; i < num_options; i++)
04069                                 if (solver_name == this->optimization->solverOptions->solverOption[ i]->solver)
04070                                         optionsVector.push_back( this->optimization->solverOptions->solverOption[ i]);
04071                 }                                       
04072                 else
04073                         throw ErrorClass("<solverOptions> object must be defined before getting the data");
04074         }
04075         else
04076                 throw ErrorClass("<optimization> object must be defined before getting the data");
04077         return optionsVector;
04078 }//getSolverOptions
04079 
04084 SolverOption** OSOption::getAllSolverOptions()
04085 {       SolverOption** optionsVector;
04086         if (this->optimization != NULL) 
04087         {       if (this->optimization->solverOptions != NULL) 
04088                         optionsVector = this->optimization->solverOptions->solverOption;
04089                 else
04090                         throw ErrorClass("<solverOptions> object must be defined before getting the data");
04091         }
04092         else
04093                 throw ErrorClass("<optimization> object must be defined before getting the data");
04094         return optionsVector;
04095 }//getAllOtherConstraintOptions
04096 
04097 
04098 
04105 /* ----------------------------------------------------------
04106  * Start with a number of set() and add() methods for arrays 
04107  * used in various subelements.
04108  * These have been put here in order of appearance
04109  * ----------------------------------------------------------*/
04110 
04114 bool OtherOptions::setOther(int numberOfOptions, OtherOption** other)
04115 {       try
04116         {       if (this->other != NULL)
04117                         throw ErrorClass( "otherOptions array previously used.");
04118                 
04119                 if (numberOfOptions < 0)
04120                         throw ErrorClass( "length of otherOptions array cannot be negative.");
04121 
04122                 this->numberOfOtherOptions = numberOfOptions;
04123                 if (numberOfOptions == 0)
04124                         return true;
04125 
04126                 this->other = new OtherOption*[numberOfOptions];
04127          
04128                 int  i;
04129                 for (i = 0; i < numberOfOptions; i++)
04130                 {        this->other[i] = new OtherOption();
04131                         *this->other[i] = *other[i];
04132                 }
04133                 return true;
04134         }
04135         catch(const ErrorClass& eclass)
04136         {       cout << eclass.errormsg << endl;
04137                 return false;
04138         }
04139 }//setOther
04140 
04144 bool OtherOptions::addOther(std::string name, std::string value, std::string description)
04145 {       try
04146         {       int nopt; int i;
04147                 if (name.empty() )
04148                         throw ErrorClass( "the name of an option cannot be empty." );
04149 
04150                 if (this->other == NULL) 
04151                         nopt = 0;
04152                 else
04153                         nopt = this->numberOfOtherOptions;
04154         
04155                 OtherOption** temp = new OtherOption*[nopt+1];  //Allocate the new pointers
04156                 for (i = 0; i < nopt; i++)
04157                         temp[i] = this->other[i];  //copy the pointers
04158 
04159                 delete[] this->other; //delete old pointers
04160         
04161 //      add in the new element
04162                 temp[ nopt] = new OtherOption();
04163 
04164                 temp[ nopt]->name = name;
04165                 temp[ nopt]->value = value;
04166                 temp[ nopt]->description = description;
04167 
04168                 this->other = temp;   //hook the new pointers into the data structure
04169                 this->numberOfOtherOptions = ++nopt;
04170 
04171                 return true;
04172         }
04173         catch(const ErrorClass& eclass)
04174         {       cout << eclass.errormsg << endl;
04175                 return false;
04176         }
04177 }//addOther
04178 
04184 bool JobDependencies::setJobID(int numberOfJobIDs, std::string *jobID)
04185 {       try
04186         {       if (this->jobID != NULL)
04187                         throw ErrorClass( "jobID array previously used.");
04188 
04189                 if (numberOfJobIDs < 0)
04190                         throw ErrorClass( "length of jobID array cannot be negative.");
04191 
04192                 this->numberOfJobIDs = numberOfJobIDs;
04193                 if (numberOfJobIDs == 0)
04194                         return true;
04195 
04196                 this->jobID = new std::string[numberOfJobIDs];
04197                 int i;
04198                 for (i = 0; i < numberOfJobIDs; i++)
04199                         this->jobID[i] = jobID[i];
04200                 
04201                 return true;
04202         }
04203         catch(const ErrorClass& eclass)
04204         {       cout << eclass.errormsg << endl;
04205                 return false;
04206         }
04207 }//setJobID
04208 
04214 bool JobDependencies::addJobID(std::string jobID)
04215 {       try
04216         {       int nopt;
04217                 if (jobID.empty() )
04218                         throw ErrorClass( "the name of a jobID cannot be empty." );
04219 
04220                 if (this->jobID == NULL) 
04221                         nopt = 0;
04222                 else
04223                         nopt = this->numberOfJobIDs;
04224 
04225                 std::string* temp = new std::string[nopt+1];
04226                 int i;
04227                 for (i = 0; i < nopt; i++)
04228                         temp[i] = this->jobID[i]; // create the new jobID
04229 
04230                 delete[] this->jobID;
04231                 
04232                 temp[nopt] = jobID;
04233 
04234                 this->jobID = temp;
04235                 this->numberOfJobIDs = ++nopt;
04236                 return true;
04237         }
04238         catch(const ErrorClass& eclass)
04239         {       cout << eclass.errormsg << endl;
04240                 return false;
04241         }
04242 }//addJobID
04243 
04250 bool DirectoriesAndFiles::setPath(int numberOfPaths, std::string *path)
04251 {       try
04252         {       if (this->path != NULL)
04253                         throw ErrorClass( "path array previously used.");
04254 
04255                 if (numberOfPaths < 0)
04256                         throw ErrorClass( "length of path array cannot be negative.");
04257 
04258                 this->numberOfPaths = numberOfPaths;
04259                 if (numberOfPaths == 0)
04260                         return true;
04261 
04262                 this->path = new std::string[numberOfPaths];
04263                 int i;
04264                 for (i = 0; i < numberOfPaths; i++)
04265                         this->path[i] = path[i];
04266                 
04267                 return true;
04268         }
04269         catch(const ErrorClass& eclass)
04270         {       cout << eclass.errormsg << endl;
04271                 return false;
04272         }
04273 }//setPath
04274 
04280 bool DirectoriesAndFiles::addPath(std::string path)
04281 {       try
04282         {       int nopt;
04283                 if (path.empty() )
04284                         throw ErrorClass( "the path cannot be empty." );
04285 
04286                 if (this->path == NULL) 
04287                         nopt = 0;
04288                 else
04289                         nopt = this->numberOfPaths;
04290 
04291                 std::string* temp = new std::string[nopt+1];
04292                 int i;
04293                 for (i = 0; i < nopt; i++)
04294                         temp[i] = this->path[i]; // create the new path
04295 
04296                 delete[] this->path;
04297                 
04298                 temp[nopt] = path;
04299 
04300                 this->path = temp;
04301                 this->numberOfPaths = ++nopt;
04302                 return true;
04303         }
04304         catch(const ErrorClass& eclass)
04305         {       cout << eclass.errormsg << endl;
04306                 return false;
04307         }
04308 }//addPath
04309 
04316 bool PathPairs::setPathPair(int numberOfPathPairs, PathPair **pathPair)
04317 {       try
04318         {       if (this->pathPair != NULL)
04319                         throw ErrorClass( "pathPair array previously used.");
04320                 
04321                 if (numberOfPathPairs < 0)
04322                         throw ErrorClass( "length of pathPair array cannot be negative.");
04323 
04324                 this->numberOfPathPairs = numberOfPathPairs;
04325                 if (numberOfPathPairs == 0)
04326                         return true;
04327 
04328                 this->pathPair = new PathPair*[numberOfPathPairs];
04329          
04330                 int  i;
04331                 for (i = 0; i < numberOfPathPairs; i++)
04332                 {        this->pathPair[i] = new PathPair();
04333                         *this->pathPair[i] = *pathPair[i];
04334                 }
04335                 return true;
04336         }
04337         catch(const ErrorClass& eclass)
04338         {       cout << eclass.errormsg << endl;
04339                 return false;
04340         }
04341 }//setPathPair
04342 
04343 
04344 bool PathPairs::setPathPair(std::string *from, std::string *to, bool *makeCopy, int numberOfPathPairs)
04345 {
04346 //      if (this->pathPair != NULL)
04347 //              return false;
04348                 
04349         this->numberOfPathPairs = numberOfPathPairs;
04350         if (numberOfPathPairs == 0)
04351                 return true;
04352 
04353         this->pathPair = new PathPair*[numberOfPathPairs];
04354          
04355         int  i;
04356         for (i = 0; i < numberOfPathPairs; i++)
04357         {
04358                 this->pathPair[i] = new PathPair();
04359                 this->pathPair[i]->from = from[i];
04360                 this->pathPair[i]->to = to[i];
04361                 this->pathPair[i]->makeCopy = makeCopy[i];
04362         }
04363         return true;
04364 }//setPathPair
04365 
04373 bool PathPairs::addPathPair(std::string fromPath, std::string toPath, bool makeCopy)
04374 {       try
04375         {       int nopt; int i;
04376                 if (fromPath.empty() )
04377                         throw ErrorClass( "the \"from\" path cannot be empty." );
04378                 if (toPath.empty() )
04379                         throw ErrorClass( "the \"to\" path cannot be empty." );
04380 
04381                 if (this->pathPair == NULL) 
04382                         nopt = 0;
04383                 else
04384                         nopt = this->numberOfPathPairs;
04385         
04386                 PathPair** temp = new PathPair*[nopt+1];  //Allocate the new pointers
04387                 for (i = 0; i < nopt; i++)
04388                         temp[i] = this->pathPair[i];  //copy the pointers
04389 
04390                 delete[] this->pathPair; //delete old pointers
04391         
04392 //      add in the new element
04393                 temp[ nopt] = new PathPair();
04394 
04395                 temp[ nopt]->from = fromPath;
04396                 temp[ nopt]->to = toPath;
04397                 temp[ nopt]->makeCopy = makeCopy;
04398 
04399                 this->pathPair = temp;   //hook the new pointers into the data structure
04400                 this->numberOfPathPairs = ++nopt;
04401 
04402                 return true;
04403         }
04404         catch(const ErrorClass& eclass)
04405         {       cout << eclass.errormsg << endl;
04406                 return false;
04407         }
04408 }//addPathPair
04409 
04416 bool Processes::setProcess(int numberOfProcesses, std::string *process)
04417 {       try
04418         {       if (this->process != NULL)
04419                         throw ErrorClass( "process array previously used.");
04420 
04421                 if (numberOfProcesses < 0)
04422                         throw ErrorClass( "length of process array cannot be negative.");
04423 
04424                 this->numberOfProcesses= numberOfProcesses;
04425                 if (numberOfProcesses == 0)
04426                         return true;
04427 
04428                 this->process = new std::string[numberOfProcesses];
04429                 int i;
04430                 for (i = 0; i < numberOfProcesses; i++)
04431                         this->process[i] = process[i];
04432                 
04433                 return true;
04434         }
04435         catch(const ErrorClass& eclass)
04436         {       cout << eclass.errormsg << endl;
04437                 return false;
04438         }
04439 }//setProcess
04440 
04446 bool Processes::addProcess(std::string process)
04447 {       try
04448         {       int nopt;
04449                 if (process.empty() )
04450                         throw ErrorClass( "the name of a process cannot be empty." );
04451 
04452                 if (this->process == NULL) 
04453                         nopt = 0;
04454                 else
04455                         nopt = this->numberOfProcesses;
04456 
04457                 std::string* temp = new std::string[nopt+1];
04458                 int i;
04459                 for (i = 0; i < nopt; i++)
04460                         temp[i] = this->process[i]; // create the new jobID
04461 
04462                 delete[] this->process;
04463                 
04464                 temp[nopt] = process;
04465 
04466                 this->process = temp;
04467                 this->numberOfProcesses = ++nopt;
04468                 return true;
04469         }
04470         catch(const ErrorClass& eclass)
04471         {       cout << eclass.errormsg << endl;
04472                 return false;
04473         }
04474 }//addProcess
04475 
04482 bool InitVariableValues::setVar(int numberOfVar, InitVarValue **var)
04483 {       try
04484         {       if (this->var != NULL)
04485                         throw ErrorClass( "InitVarValue array previously used.");
04486                 
04487                 if (numberOfVar < 0)
04488                         throw ErrorClass( "length of var array cannot be negative.");
04489 
04490                 this->numberOfVar = numberOfVar;
04491                 if (numberOfVar == 0)
04492                         return true;
04493 
04494                 this->var = new InitVarValue*[numberOfVar];
04495          
04496                 int  i;
04497                 for (i = 0; i < numberOfVar; i++)
04498                 {        this->var[i] = new InitVarValue();
04499                         *this->var[i] = *var[i];
04500                 }
04501                 return true;
04502         }
04503         catch(const ErrorClass& eclass)
04504         {       cout << eclass.errormsg << endl;
04505                 return false;
04506         }
04507 }//setVar
04508 
04516 bool InitVariableValues::setVar(int numberOfVar, int *idx, double *value)
04517 {       
04518         if (this->var != NULL)
04519                 return false;
04520                 
04521         if (numberOfVar < 0)
04522                 return false;
04523 
04524         this->numberOfVar = numberOfVar;
04525         if (numberOfVar == 0)
04526                 return true;
04527 
04528         this->var = new InitVarValue*[numberOfVar];
04529          
04530         int  i;
04531         for (i = 0; i < numberOfVar; i++)
04532         {
04533                 this->var[i] = new InitVarValue();
04534                 this->var[i]->idx = idx[i];
04535                 this->var[i]->value = value[i];
04536         }
04537         return true;
04538 }//setVar
04539 
04540 
04547 bool InitVariableValues::addVar(int idx, double value)
04548 {       try
04549         {       int nopt; int i;
04550                 if (idx < 0)
04551                         throw ErrorClass( "the index of a variable cannot be negative." );
04552 
04553                 if (this->var == NULL) 
04554                         nopt = 0;
04555                 else
04556                         nopt = this->numberOfVar;
04557         
04558                 InitVarValue** temp = new InitVarValue*[nopt+1];  //Allocate the new pointers
04559                 for (i = 0; i < nopt; i++)
04560                         temp[i] = this->var[i];  //copy the pointers
04561 
04562                 delete[] this->var; //delete old pointers
04563         
04564 //      add in the new element
04565                 temp[ nopt] = new InitVarValue();
04566 
04567                 temp[ nopt]->idx = idx;
04568                 temp[ nopt]->value = value;
04569 
04570                 this->var = temp;   //hook the new pointers into the data structure
04571                 this->numberOfVar = ++nopt;
04572 
04573                 return true;
04574         }
04575         catch(const ErrorClass& eclass)
04576         {       cout << eclass.errormsg << endl;
04577                 return false;
04578         }
04579 }//addVar
04580 
04587 bool InitVariableValuesString::setVar(int numberOfVar, InitVarValueString **var)
04588 {       try
04589         {       if (this->var != NULL)
04590                         throw ErrorClass( "InitVarValueString array previously used.");
04591                 
04592                 if (numberOfVar < 0)
04593                         throw ErrorClass( "length of var array cannot be negative.");
04594 
04595                 this->numberOfVar = numberOfVar;
04596                 if (numberOfVar == 0)
04597                         return true;
04598 
04599                 this->var = new InitVarValueString*[numberOfVar];
04600          
04601                 int  i;
04602                 for (i = 0; i < numberOfVar; i++)
04603                 {        this->var[i] = new InitVarValueString();
04604                         *this->var[i] = *var[i];
04605                 }
04606                 return true;
04607         }
04608         catch(const ErrorClass& eclass)
04609         {       cout << eclass.errormsg << endl;
04610                 return false;
04611         }
04612 }//setVar
04613 
04614 
04622 bool InitVariableValuesString::setVar(int numberOfVar, int *idx, std::string *value)
04623 {       
04624         if (this->var != NULL)
04625                 return false;
04626                 
04627         if (numberOfVar < 0)
04628                 return false;
04629 
04630         this->numberOfVar = numberOfVar;
04631         if (numberOfVar == 0)
04632                 return true;
04633 
04634         this->var = new InitVarValueString*[numberOfVar];
04635          
04636         int  i;
04637         for (i = 0; i < numberOfVar; i++)
04638         {
04639                 this->var[i] = new InitVarValueString();
04640                 this->var[i]->idx = idx[i];
04641                 this->var[i]->value = value[i];
04642         }
04643         return true;
04644 }//setVar
04645 
04652 bool InitVariableValuesString::addVar(int idx, std::string value)
04653 {       try
04654         {       int nopt; int i;
04655                 if (idx < 0)
04656                         throw ErrorClass( "the index of a variable cannot be negative." );
04657 
04658                 if (this->var == NULL) 
04659                         nopt = 0;
04660                 else
04661                         nopt = this->numberOfVar;
04662         
04663                 InitVarValueString** temp = new InitVarValueString*[nopt+1];  //Allocate the new pointers
04664                 for (i = 0; i < nopt; i++)
04665                         temp[i] = this->var[i];  //copy the pointers
04666 
04667                 delete[] this->var; //delete old pointers
04668         
04669 //      add in the new element
04670                 temp[ nopt] = new InitVarValueString();
04671 
04672                 temp[ nopt]->idx = idx;
04673                 temp[ nopt]->value = value;
04674 
04675                 this->var = temp;   //hook the new pointers into the data structure
04676                 this->numberOfVar = ++nopt;
04677 
04678                 return true;
04679         }
04680         catch(const ErrorClass& eclass)
04681         {       cout << eclass.errormsg << endl;
04682                 return false;
04683         }
04684 }//addVar
04685 
04692 bool InitialBasisStatus::setVar(int numberOfVar, InitBasStatus **var)
04693 {       try
04694         {       if (this->var != NULL)
04695                         throw ErrorClass( "InitBasStatus array previously used.");
04696                 
04697                 if (numberOfVar < 0)
04698                         throw ErrorClass( "length of var array cannot be negative.");
04699 
04700                 this->numberOfVar = numberOfVar;
04701                 if (numberOfVar == 0)
04702                         return true;
04703 
04704                 this->var = new InitBasStatus*[numberOfVar];
04705          
04706                 int  i;
04707                 for (i = 0; i < numberOfVar; i++)
04708                 {        this->var[i] = new InitBasStatus();
04709                         *this->var[i] = *var[i];
04710                 }
04711                 return true;
04712         }
04713         catch(const ErrorClass& eclass)
04714         {       cout << eclass.errormsg << endl;
04715                 return false;
04716         }
04717 }//setVar
04718 
04725 bool InitialBasisStatus::addVar(int idx, std::string value)
04726 {       try
04727         {       int nopt; int i;
04728                 if (idx < 0)
04729                         throw ErrorClass( "the index of a variable cannot be negative." );
04730                 if (value != "atLower" && value != "basic" && value != "unknown" && 
04731                         value != "atUpper" && value != "superbasic" )
04732                         throw ErrorClass( "Illegal basis status " + value );
04733 
04734                 if (this->var == NULL) 
04735                         nopt = 0;
04736                 else
04737                         nopt = this->numberOfVar;
04738         
04739                 InitBasStatus** temp = new InitBasStatus*[nopt+1];  //Allocate the new pointers
04740                 for (i = 0; i < nopt; i++)
04741                         temp[i] = this->var[i];  //copy the pointers
04742 
04743                 delete[] this->var; //delete old pointers
04744         
04745 //      add in the new element
04746                 temp[ nopt] = new InitBasStatus();
04747 
04748                 temp[ nopt]->idx = idx;
04749                 temp[ nopt]->value = value;
04750 
04751                 this->var = temp;   //hook the new pointers into the data structure
04752                 this->numberOfVar = ++nopt;
04753 
04754                 return true;
04755         }
04756         catch(const ErrorClass& eclass)
04757         {       cout << eclass.errormsg << endl;
04758                 return false;
04759         }
04760 }//addVar
04761 
04768 bool IntegerVariableBranchingWeights::setVar(int numberOfVar, BranchingWeight **var)
04769 {       try
04770         {       if (this->var != NULL)
04771                 return false;
04772                 
04773                 if (numberOfVar < 0)
04774                 return false;
04775 
04776                 this->numberOfVar = numberOfVar;
04777                 if (numberOfVar == 0)
04778                         return true;
04779 
04780                 this->var = new BranchingWeight*[numberOfVar];
04781          
04782                 int  i;
04783                 for (i = 0; i < numberOfVar; i++)
04784                 {        this->var[i] = new BranchingWeight();
04785                         *this->var[i] = *var[i];
04786                 }
04787                 return true;
04788         }
04789         catch(const ErrorClass& eclass)
04790         {       cout << eclass.errormsg << endl;
04791                 return false;
04792         }
04793 }//setVar
04794 
04795 
04803 bool IntegerVariableBranchingWeights::setVar(int numberOfVar, int *idx, double *value)
04804 {       
04805         if (this->var != NULL)
04806                 return false;
04807                 
04808         if (numberOfVar < 0)
04809                 return false;
04810 
04811         this->numberOfVar = numberOfVar;
04812         if (numberOfVar == 0)
04813                 return true;
04814 
04815         this->var = new BranchingWeight*[numberOfVar];
04816          
04817         int  i;
04818         for (i = 0; i < numberOfVar; i++)
04819         {
04820                 this->var[i] = new BranchingWeight();
04821                 this->var[i]->idx = idx[i];
04822                 this->var[i]->value = value[i];
04823         }
04824         return true;
04825 }//setVar
04826 
04827 
04828 
04829 
04836 bool IntegerVariableBranchingWeights::addVar(int idx, double value)
04837 {       try
04838         {       int nopt; int i;
04839                 if (idx < 0)
04840                         throw ErrorClass( "the index of a variable cannot be negative." );
04841 
04842                 if (this->var == NULL) 
04843                         nopt = 0;
04844                 else
04845                         nopt = this->numberOfVar;
04846         
04847                 BranchingWeight** temp = new BranchingWeight*[nopt+1];  //Allocate the new pointers
04848                 for (i = 0; i < nopt; i++)
04849                         temp[i] = this->var[i];  //copy the pointers
04850 
04851                 delete[] this->var; //delete old pointers
04852         
04853 //      add in the new element
04854                 temp[ nopt] = new BranchingWeight();
04855 
04856                 temp[ nopt]->idx = idx;
04857                 temp[ nopt]->value = value;
04858 
04859                 this->var = temp;   //hook the new pointers into the data structure
04860                 this->numberOfVar = ++nopt;
04861 
04862                 return true;
04863         }
04864         catch(const ErrorClass& eclass)
04865         {       cout << eclass.errormsg << endl;
04866                 return false;
04867         }
04868 }//addVar
04869 
04876 bool SOSWeights::setVar(int numberOfVar, BranchingWeight **var)
04877 {       try
04878         {       if (this->var != NULL)
04879                         throw ErrorClass( "BranchingWeight array previously used.");
04880                 
04881                 if (numberOfVar < 0)
04882                         throw ErrorClass( "length of var array cannot be negative.");
04883 
04884                 this->numberOfVar = numberOfVar;
04885                 if (numberOfVar == 0)
04886                         return true;
04887 
04888                 this->var = new BranchingWeight*[numberOfVar];
04889          
04890                 int  i;
04891                 for (i = 0; i < numberOfVar; i++)
04892                 {        this->var[i] = new BranchingWeight();
04893                         *this->var[i] = *var[i];
04894                 }
04895                 return true;
04896         }
04897         catch(const ErrorClass& eclass)
04898         {       cout << eclass.errormsg << endl;
04899                 return false;
04900         }
04901 }//setVar
04902 
04909 bool SOSWeights::addVar(int idx, double value)
04910 {       try
04911         {       int nopt; int i;
04912                 if (idx < 0)
04913                         throw ErrorClass( "the index of a variable cannot be negative." );
04914 
04915                 if (this->var == NULL) 
04916                         nopt = 0;
04917                 else
04918                         nopt = this->numberOfVar;
04919         
04920                 BranchingWeight** temp = new BranchingWeight*[nopt+1];  //Allocate the new pointers
04921                 for (i = 0; i < nopt; i++)
04922                         temp[i] = this->var[i];  //copy the pointers
04923 
04924                 delete[] this->var; //delete old pointers
04925         
04926 //      add in the new element
04927                 temp[ nopt] = new BranchingWeight();
04928 
04929                 temp[ nopt]->idx = idx;
04930                 temp[ nopt]->value = value;
04931 
04932                 this->var = temp;   //hook the new pointers into the data structure
04933                 this->numberOfVar = ++nopt;
04934 
04935                 return true;
04936         }
04937         catch(const ErrorClass& eclass)
04938         {       cout << eclass.errormsg << endl;
04939                 return false;
04940         }
04941 }//addVar
04942 
04949 bool SOSVariableBranchingWeights::setSOS(int numberOfSOS, SOSWeights **sos)
04950 {       try
04951         {       if (this->sos != NULL)
04952                         throw ErrorClass( "SOS array previously used.");
04953                 
04954                 if (numberOfSOS < 0)
04955                         throw ErrorClass( "length of sos array cannot be negative.");
04956                 
04957                 this->numberOfSOS = numberOfSOS;
04958                 if (numberOfSOS == 0) return true;
04959 
04960                 this->sos = new SOSWeights*[numberOfSOS];
04961          
04962                 int  i, j;
04963                 for (i = 0; i < numberOfSOS; i++)
04964                 {       this->sos[i] = new SOSWeights();
04965                         this->sos[i]->sosIdx      = sos[i]->sosIdx;
04966                         this->sos[i]->groupWeight = sos[i]->groupWeight;
04967 
04968                         if (sos[i]->numberOfVar < 0)
04969                                 throw ErrorClass( "the number of variables in the SOS cannot be negative.");
04970 
04971                         this->sos[i]->numberOfVar = sos[i]->numberOfVar;
04972 
04973                         if (sos[i]->numberOfVar > 0) 
04974                         {       this->sos[i]->var = new BranchingWeight*[sos[i]->numberOfVar];
04975                                 for (j = 0; j < sos[i]->numberOfVar; j++)
04976                                 {        this->sos[i]->var[j] = new BranchingWeight();
04977                                         *this->sos[i]->var[j] = *sos[i]->var[j];
04978                                 }
04979                         }
04980                 }
04981                 return true;
04982         }
04983         catch(const ErrorClass& eclass)
04984         {       cout << eclass.errormsg << endl;
04985                 return false;
04986         }
04987 }//setSOS
04988 
04994 bool SOSVariableBranchingWeights::addSOS(int sosIdx, int nvar, double weight, int* idx, double* value)
04995 {       try
04996         {       int nopt; int i;
04997                 if (sosIdx < 0)
04998                         throw ErrorClass( "the index of the SOS cannot be negative." );
04999                 if (nvar < 0)
05000                         throw ErrorClass( "the number of variables in the SOS cannot be negative." );
05001 
05002                 if (this->sos  == NULL) 
05003                         nopt = 0;
05004                 else
05005                         nopt = this->numberOfSOS;
05006         
05007                 SOSWeights** temp = new SOSWeights*[nopt+1];  //Allocate the new pointers
05008                 for (i = 0; i < nopt; i++)
05009                         temp[i] = this->sos[i];  //copy the pointers
05010 
05011                 delete[] this->sos; //delete old pointers
05012         
05013 //      add in the new element
05014                 temp[ nopt] = new SOSWeights();
05015 
05016                 temp[ nopt]->sosIdx = sosIdx;
05017                 temp[ nopt]->groupWeight = weight;
05018                 temp[ nopt]->numberOfVar = nvar;
05019                 temp[ nopt]->var = new BranchingWeight*[nvar];
05020                 for (i = 0; i < nvar; i++)
05021                 {       temp[nopt]->var[i] = new BranchingWeight();
05022                         temp[nopt]->var[i]->idx   = idx[i];
05023                         temp[nopt]->var[i]->value = value[i];
05024                 }
05025 
05026                 this->sos  = temp;   //hook the new pointers into the data structure
05027                 this->numberOfSOS = ++nopt;
05028 
05029                 return true;
05030         }
05031         catch(const ErrorClass& eclass)
05032         {       cout << eclass.errormsg << endl;
05033                 return false;
05034         }
05035 }//addSOS
05036 
05043 bool OtherVariableOption::setVar(int numberOfVar, OtherVarOption **var)
05044 {       try
05045         {       if (this->var != NULL)
05046                         throw ErrorClass( "OtherVarOption array previously used.");
05047                 
05048                 if (numberOfVar < 0)
05049                         throw ErrorClass( "length of <var> array cannot be negative.");
05050 
05051                 this->numberOfVar = numberOfVar;
05052                 if (numberOfVar == 0) return true;
05053 
05054                 this->var = new OtherVarOption*[numberOfVar];
05055          
05056                 int  i;
05057                 for (i = 0; i < numberOfVar; i++)
05058                 {        this->var[i] = new OtherVarOption();
05059                         *this->var[i] = *var[i];
05060                 }
05061                 return true;
05062         }
05063         catch(const ErrorClass& eclass)
05064         {       cout << eclass.errormsg << endl;
05065                 return false;
05066         }
05067 }//setVar
05068 
05077 bool OtherVariableOption::addVar(int idx, std::string value, std::string lbValue, std::string ubValue)
05078 {       try
05079         {       int nopt; int i;
05080                 if (idx < 0)
05081                         throw ErrorClass( "the index of a variable cannot be negative." );
05082 
05083                 if (this->var == NULL) 
05084                         nopt = 0;
05085                 else
05086                         nopt = this->numberOfVar;
05087         
05088                 OtherVarOption** temp = new OtherVarOption*[nopt+1];  //Allocate the new pointers
05089                 for (i = 0; i < nopt; i++)
05090                         temp[i] = this->var[i];  //copy the pointers
05091 
05092                 delete[] this->var; //delete old pointers
05093         
05094 //      add in the new element
05095                 temp[ nopt] = new OtherVarOption();
05096 
05097                 temp[ nopt]->idx = idx;
05098                 temp[ nopt]->value = value;
05099                 temp[ nopt]->lbValue = lbValue;
05100                 temp[ nopt]->ubValue = ubValue;
05101 
05102                 this->var = temp;   //hook the new pointers into the data structure
05103                 this->numberOfVar = ++nopt;
05104 
05105                 return true;
05106         }
05107         catch(const ErrorClass& eclass)
05108         {       cout << eclass.errormsg << endl;
05109                 return false;
05110         }
05111 }//addVar
05112 
05119 bool VariableOption::setOther(int numberOfOptions, OtherVariableOption  **other)
05120 {       try
05121         {       if (this->other != NULL)
05122                         throw ErrorClass( "otherVariableOptions array previously used.");
05123                 
05124                 if (numberOfOptions < 0)
05125                         throw ErrorClass( "length of <other> array cannot be negative.");
05126 
05127                 this->numberOfOtherVariableOptions = numberOfOptions;
05128                 if (numberOfOptions == 0) return true;
05129 
05130                 this->other = new OtherVariableOption*[numberOfOptions];
05131          
05132                 int  i, j;
05133                 for (i = 0; i < numberOfOptions; i++)
05134                 {       this->other[i] = new OtherVariableOption();
05135                         this->other[i]->name        = other[i]->name;
05136                         this->other[i]->value       = other[i]->value;
05137                         this->other[i]->solver      = other[i]->solver;
05138                         this->other[i]->category    = other[i]->category;
05139                         this->other[i]->type        = other[i]->type;
05140                         this->other[i]->description = other[i]->description;
05141 
05142                         if (other[i]->numberOfVar < 0)
05143                                 throw ErrorClass( "the number of variables in otherVariableOption cannot be negative.");
05144 
05145                         this->other[i]->numberOfVar = other[i]->numberOfVar;
05146 
05147                         if (other[i]->numberOfVar > 0) 
05148                         {
05149                                 this->other[i]->var = new OtherVarOption*[other[i]->numberOfVar];
05150                                 for (j = 0; j < other[i]->numberOfVar; j++)
05151                                 {        this->other[i]->var[j] = new OtherVarOption();
05152                                         *this->other[i]->var[j] = *other[i]->var[j];
05153                                 }
05154                         }
05155                         this->other[i]->numberOfEnumerations = other[i]->numberOfEnumerations;
05156 
05157                         if (this->other[i]->numberOfEnumerations > 0)
05158                         {       
05159                                 this->other[i]->enumeration = new OtherOptionEnumeration*[this->other[i]->numberOfEnumerations];
05160                                 for (j = 0; j < this->other[i]->numberOfEnumerations; j++)
05161                                 {
05162                                         this->other[i]->enumeration[j]  = new OtherOptionEnumeration();
05163                                         this->other[i]->enumeration[j]->setOtherOptionEnumeration(
05164                                                 other[i]->enumeration[j]->value, 
05165                                                 other[i]->enumeration[j]->description, 
05166                                                 other[i]->enumeration[j]->el, 
05167                                                 other[i]->enumeration[j]->numberOfEl);
05168                                 }
05169                         }
05170                 }
05171                 return true;
05172         }
05173         catch(const ErrorClass& eclass)
05174         {       cout << eclass.errormsg << endl;
05175                 return false;
05176         }
05177 }//setOther
05178 
05184 bool VariableOption::addOther(OtherVariableOption *other)
05185 {       try
05186         {       int nopt, i, j;
05187                 if (this->other == NULL) 
05188                         nopt = 0;
05189                 else
05190                         nopt = this->numberOfOtherVariableOptions;
05191         
05192                 OtherVariableOption** temp = new OtherVariableOption*[nopt+1];  //Allocate the new pointers
05193                 for (i = 0; i < nopt; i++)
05194                         temp[i] = this->other[i];  //copy the pointers
05195 
05196                 delete[] this->other; //delete old pointers
05197         
05198 //      add in the new element
05199                 temp[ nopt] = new OtherVariableOption();
05200                 temp[ nopt]->name        = other->name;
05201                 temp[ nopt]->value       = other->value;
05202                 temp[ nopt]->solver      = other->solver;
05203                 temp[ nopt]->category    = other->category;
05204                 temp[ nopt]->type        = other->type;
05205                 temp[ nopt]->description = other->description;
05206 
05207                 if (other->numberOfVar < 0)
05208                         throw ErrorClass( "the number of variables in otherVariableOption cannot be negative.");
05209 
05210                 temp[ nopt]->numberOfVar = other->numberOfVar;
05211 
05212                 if (other->numberOfVar > 0)
05213                 {       
05214                         temp[ nopt]->var = new OtherVarOption*[other->numberOfVar];
05215                         for (j = 0; j < other->numberOfVar; j++)
05216                         {        temp[ nopt]->var[j] = new OtherVarOption();
05217                                 *temp[ nopt]->var[j] = *other->var[j];
05218                         }
05219                 }
05220 
05221                 temp[ nopt]->numberOfEnumerations = other->numberOfEnumerations;
05222 
05223                 if (other->numberOfEnumerations > 0)
05224                 {       
05225                         temp[ nopt]->enumeration = new OtherOptionEnumeration*[other->numberOfEnumerations];
05226                         for (j = 0; j < other->numberOfEnumerations; j++)
05227                         {
05228                                 temp[ nopt]->enumeration[j]  = new OtherOptionEnumeration();
05229                                 temp[ nopt]->enumeration[j]->setOtherOptionEnumeration(
05230                                         other->enumeration[j]->value, 
05231                                         other->enumeration[j]->description, 
05232                                         other->enumeration[j]->el, 
05233                                         other->enumeration[j]->numberOfEl);
05234                         }
05235                 }
05236 
05237 
05238                 this->other = temp;   //hook the new pointers into the data structure
05239                 this->numberOfOtherVariableOptions = ++nopt;
05240 
05241                 return true;
05242         }
05243         catch(const ErrorClass& eclass)
05244         {       cout << eclass.errormsg << endl;
05245                 return false;
05246         }
05247 }//addOther
05248 
05255 bool InitObjectiveValues::setObj(int numberOfObj, InitObjValue **obj)
05256 {       try
05257         {       if (this->obj != NULL)
05258                         throw ErrorClass( "InitObjValue array previously used.");
05259                 
05260                 if (numberOfObj < 0)
05261                         throw ErrorClass( "length of obj array cannot be negative.");
05262 
05263                 this->numberOfObj = numberOfObj;
05264                 if (numberOfObj == 0)
05265                         return true;
05266 
05267                 this->obj = new InitObjValue*[numberOfObj];
05268          
05269                 int  i;
05270                 for (i = 0; i < numberOfObj; i++)
05271                 {        this->obj[i] = new InitObjValue();
05272                         *this->obj[i] = *obj[i];
05273                 }
05274                 return true;
05275         }
05276         catch(const ErrorClass& eclass)
05277         {       cout << eclass.errormsg << endl;
05278                 return false;
05279         }
05280 }//setObj
05281 
05282 bool InitObjectiveValues::setObj(int numberOfObj, int *idx, double *value)
05283 {       
05284         if (this->obj != NULL) return false;
05285                 
05286         if (numberOfObj < 0) return false;
05287 
05288         this->numberOfObj = numberOfObj;
05289         if (numberOfObj == 0) return true;
05290 
05291         this->obj = new InitObjValue*[numberOfObj];
05292          
05293         int  i;
05294         for (i = 0; i < numberOfObj; i++)
05295         {
05296                 this->obj[i] = new InitObjValue();
05297                 this->obj[i]->idx = idx[i];
05298                 this->obj[i]->value = value[i];
05299         }
05300         return true;
05301 }//setObj
05302 
05303 
05310 bool InitObjectiveValues::addObj(int idx, double value)
05311 {       try
05312         {       int nopt; int i;
05313                 if (idx >= 0)
05314                         throw ErrorClass( "the index of an objective must be negative." );
05315 
05316                 if (this->obj == NULL) 
05317                         nopt = 0;
05318                 else
05319                         nopt = this->numberOfObj;
05320         
05321                 InitObjValue** temp = new InitObjValue*[nopt+1];  //Allocate the new pointers
05322                 for (i = 0; i < nopt; i++)
05323                         temp[i] = this->obj[i];  //copy the pointers
05324 
05325                 delete[] this->obj; //delete old pointers
05326         
05327 //      add in the new element
05328                 temp[ nopt] = new InitObjValue();
05329 
05330                 temp[ nopt]->idx = idx;
05331                 temp[ nopt]->value = value;
05332 
05333                 this->obj = temp;   //hook the new pointers into the data structure
05334                 this->numberOfObj = ++nopt;
05335 
05336                 return true;
05337         }
05338         catch(const ErrorClass& eclass)
05339         {       cout << eclass.errormsg << endl;
05340                 return false;
05341         }
05342 }//addObj
05343 
05350 bool InitObjectiveBounds::setObj(int numberOfObj, InitObjBound **obj)
05351 {       try
05352         {       if (this->obj != NULL)
05353                         throw ErrorClass( "InitObjBound array previously used.");
05354                 
05355                 if (numberOfObj < 0)
05356                         throw ErrorClass( "length of obj array cannot be negative.");
05357 
05358                 this->numberOfObj = numberOfObj;
05359                 if (numberOfObj == 0)
05360                         return true;
05361 
05362                 this->obj = new InitObjBound*[numberOfObj];
05363          
05364                 int  i;
05365                 for (i = 0; i < numberOfObj; i++)
05366                 {        this->obj[i] = new InitObjBound();
05367                         *this->obj[i] = *obj[i];
05368                 }
05369                 return true;
05370         }
05371         catch(const ErrorClass& eclass)
05372         {       cout << eclass.errormsg << endl;
05373                 return false;
05374         }
05375 }//setObj
05376 
05377 bool InitObjectiveBounds::setObj(int numberOfObj, int *idx, double *lbValue, double *ubValue)
05378 {       
05379         if (this->obj != NULL)
05380                 return false;
05381                 
05382         if (numberOfObj < 0)
05383                 return false;
05384 
05385         this->numberOfObj = numberOfObj;
05386         if (numberOfObj == 0)
05387                 return true;
05388 
05389         this->obj = new InitObjBound*[numberOfObj];
05390          
05391         int  i;
05392         for (i = 0; i < numberOfObj; i++)
05393         {
05394                 this->obj[i] = new InitObjBound();
05395                 this->obj[i]->idx = idx[i];
05396                 this->obj[i]->lbValue = lbValue[i];
05397                 this->obj[i]->ubValue = ubValue[i];
05398         }
05399         return true;
05400 }//setObj
05401 
05402 
05410 bool InitObjectiveBounds::addObj(int idx, double lbValue, double ubValue)
05411 {       try
05412         {       int nopt; int i;
05413                 if (idx >= 0)
05414                         throw ErrorClass( "the index of an objective must be negative." );
05415 
05416                 if (this->obj == NULL) 
05417                         nopt = 0;
05418                 else
05419                         nopt = this->numberOfObj;
05420         
05421                 InitObjBound** temp = new InitObjBound*[nopt+1];  //Allocate the new pointers
05422                 for (i = 0; i < nopt; i++)
05423                         temp[i] = this->obj[i];  //copy the pointers
05424 
05425                 delete[] this->obj; //delete old pointers
05426         
05427 //      add in the new element
05428                 temp[ nopt] = new InitObjBound();
05429 
05430                 temp[ nopt]->idx = idx;
05431                 temp[ nopt]->lbValue = lbValue;
05432                 temp[ nopt]->ubValue = ubValue;
05433 
05434                 this->obj = temp;   //hook the new pointers into the data structure
05435                 this->numberOfObj = ++nopt;
05436 
05437                 return true;
05438         }
05439         catch(const ErrorClass& eclass)
05440         {       cout << eclass.errormsg << endl;
05441                 return false;
05442         }
05443 }//addObj
05444 
05451 bool OtherObjectiveOption::setObj(int numberOfObj, OtherObjOption **obj)
05452 {       try
05453         {       if (this->obj != NULL)
05454                         throw ErrorClass( "OtherObjOption array previously used.");
05455                 
05456                 if (numberOfObj < 0)
05457                         throw ErrorClass( "length of <obj> array cannot be negative.");
05458 
05459                 this->numberOfObj= numberOfObj;
05460                 if (numberOfObj == 0)
05461                         return true;
05462 
05463                 this->obj = new OtherObjOption*[numberOfObj];
05464          
05465                 int  i;
05466                 for (i = 0; i < numberOfObj; i++)
05467                 {        this->obj[i] = new OtherObjOption();
05468                         *this->obj[i] = *obj[i];
05469                 }
05470                 return true;
05471         }
05472         catch(const ErrorClass& eclass)
05473         {       cout << eclass.errormsg << endl;
05474                 return false;
05475         }
05476 }//setObj
05477 
05486 bool OtherObjectiveOption::addObj(int idx, std::string value, std::string lbValue, std::string ubValue)
05487 {       try
05488         {       int nopt; int i;
05489                 if (idx >= 0)
05490                         throw ErrorClass( "the index of an objective must be negative." );
05491 
05492                 if (this->obj == NULL) 
05493                         nopt = 0;
05494                 else
05495                         nopt = this->numberOfObj;
05496         
05497                 OtherObjOption** temp = new OtherObjOption*[nopt+1];  //Allocate the new pointers
05498                 for (i = 0; i < nopt; i++)
05499                         temp[i] = this->obj[i];  //copy the pointers
05500 
05501                 delete[] this->obj; //delete old pointers
05502         
05503 //      add in the new element
05504                 temp[ nopt] = new OtherObjOption();
05505 
05506                 temp[ nopt]->idx = idx;
05507                 temp[ nopt]->value = value;
05508                 temp[ nopt]->lbValue = lbValue;
05509                 temp[ nopt]->ubValue = ubValue;
05510 
05511                 this->obj = temp;   //hook the new pointers into the data structure
05512                 this->numberOfObj = ++nopt;
05513 
05514                 return true;
05515         }
05516         catch(const ErrorClass& eclass)
05517         {       cout << eclass.errormsg << endl;
05518                 return false;
05519         }
05520 }//addObj
05521 
05528 bool ObjectiveOption::setOther(int numberOfOptions, OtherObjectiveOption  **other)
05529 {       try
05530         {       if (this->other != NULL)
05531                         throw ErrorClass( "otherObjectiveOptions array previously used.");
05532                 
05533                 if (numberOfOptions < 0)
05534                         throw ErrorClass( "length of <other> array cannot be negative.");
05535 
05536                 this->numberOfOtherObjectiveOptions = numberOfOptions;
05537                 if (numberOfOptions == 0) return true;
05538 
05539                 this->other = new OtherObjectiveOption*[numberOfOptions];
05540          
05541                 int  i, j;
05542                 for (i = 0; i < numberOfOptions; i++)
05543                 {       this->other[i] = new OtherObjectiveOption();
05544                         this->other[i]->name        = other[i]->name;
05545                         this->other[i]->value       = other[i]->value;
05546                         this->other[i]->solver      = other[i]->solver;
05547                         this->other[i]->category    = other[i]->category;
05548                         this->other[i]->type        = other[i]->type;
05549                         this->other[i]->description = other[i]->description;
05550 
05551                         if (other[i]->numberOfObj < 0)
05552                                 throw ErrorClass( "the number of objectives in otherObjectiveOption cannot be negative.");
05553 
05554                         this->other[i]->numberOfObj = other[i]->numberOfObj;
05555 
05556                         if (other[i]->numberOfObj > 0) 
05557                         {
05558                                 this->other[i]->obj = new OtherObjOption*[other[i]->numberOfObj];
05559                                 for (j = 0; j < other[i]->numberOfObj; j++)
05560                                 {        this->other[i]->obj[j] = new OtherObjOption();
05561                                         *this->other[i]->obj[j] = *other[i]->obj[j];
05562                                 }
05563                         }
05564                         this->other[i]->numberOfEnumerations = other[i]->numberOfEnumerations;
05565 
05566                         if (this->other[i]->numberOfEnumerations > 0)
05567                         {       
05568                                 this->other[i]->enumeration = new OtherOptionEnumeration*[this->other[i]->numberOfEnumerations];
05569                                 for (j = 0; j < this->other[i]->numberOfEnumerations; j++)
05570                                 {
05571                                         this->other[i]->enumeration[j]  = new OtherOptionEnumeration();
05572                                         this->other[i]->enumeration[j]->setOtherOptionEnumeration(
05573                                                 other[i]->enumeration[j]->value, 
05574                                                 other[i]->enumeration[j]->description, 
05575                                                 other[i]->enumeration[j]->el, 
05576                                                 other[i]->enumeration[j]->numberOfEl);
05577                                 }
05578                         }
05579                 }
05580                 return true;
05581         }
05582         catch(const ErrorClass& eclass)
05583         {       cout << eclass.errormsg << endl;
05584                 return false;
05585         }
05586 }//setOther
05587 
05593 bool ObjectiveOption::addOther(OtherObjectiveOption *other)
05594 {       try
05595         {       int nopt, i, j;
05596                 if (this->other == NULL) 
05597                         nopt = 0;
05598                 else
05599                         nopt = this->numberOfOtherObjectiveOptions;
05600         
05601                 OtherObjectiveOption** temp = new OtherObjectiveOption*[nopt+1];  //Allocate the new pointers
05602                 for (i = 0; i < nopt; i++)
05603                         temp[i] = this->other[i];  //copy the pointers
05604 
05605                 delete[] this->other; //delete old pointers
05606         
05607 //      add in the new element
05608                 temp[ nopt] = new OtherObjectiveOption();
05609                 temp[ nopt]->name        = other->name;
05610                 temp[ nopt]->value       = other->value;
05611                 temp[ nopt]->solver      = other->solver;
05612                 temp[ nopt]->category    = other->category;
05613                 temp[ nopt]->type        = other->type;
05614                 temp[ nopt]->description = other->description;
05615 
05616                 if (other->numberOfObj < 0)
05617                         throw ErrorClass( "the number of objectives in otherObjectiveOption cannot be negative.");
05618 
05619                 temp[ nopt]->numberOfObj = other->numberOfObj;
05620 
05621                 if (other->numberOfObj > 0) 
05622                 {       
05623                         temp[ nopt]->obj = new OtherObjOption*[other->numberOfObj];
05624                         for (j = 0; j < other->numberOfObj; j++)
05625                         {        temp[ nopt]->obj[j] = new OtherObjOption();
05626                                 *temp[ nopt]->obj[j] = *other->obj[j];
05627                         }
05628                 }
05629 
05630                 if (other->numberOfEnumerations < 0)
05631                         throw ErrorClass( "the number of enumerations in otherObjectiveOption cannot be negative.");
05632 
05633                 temp[ nopt]->numberOfEnumerations = other->numberOfEnumerations;
05634 
05635                 if (other->numberOfEnumerations > 0)
05636                 {       
05637                         temp[ nopt]->enumeration = new OtherOptionEnumeration*[other->numberOfEnumerations];
05638                         for (j = 0; j < other->numberOfEnumerations; j++)
05639                         {
05640                                 temp[ nopt]->enumeration[j]  = new OtherOptionEnumeration();
05641                                 temp[ nopt]->enumeration[j]->setOtherOptionEnumeration(
05642                                         other->enumeration[j]->value, 
05643                                         other->enumeration[j]->description, 
05644                                         other->enumeration[j]->el, 
05645                                         other->enumeration[j]->numberOfEl);
05646                         }
05647                 }
05648 
05649 
05650                 this->other = temp;   //hook the new pointers into the data structure
05651                 this->numberOfOtherObjectiveOptions = ++nopt;
05652 
05653                 return true;
05654         }
05655         catch(const ErrorClass& eclass)
05656         {       cout << eclass.errormsg << endl;
05657                 return false;
05658         }
05659 }//addOther
05660 
05667 bool InitConstraintValues::setCon(int numberOfCon, InitConValue **con)
05668 {       try
05669         {       if (this->con != NULL)
05670                         throw ErrorClass( "InitConValue array previously used.");
05671                 
05672                 if (numberOfCon < 0)
05673                         throw ErrorClass( "length of con array cannot be negative.");
05674 
05675                 this->numberOfCon = numberOfCon;
05676                 if (numberOfCon == 0)
05677                         return true;
05678 
05679                 this->con = new InitConValue*[numberOfCon];
05680          
05681                 int  i;
05682                 for (i = 0; i < numberOfCon; i++)
05683                 {        this->con[i] = new InitConValue();
05684                         *this->con[i] = *con[i];
05685                 }
05686                 return true;
05687         }
05688         catch(const ErrorClass& eclass)
05689         {       cout << eclass.errormsg << endl;
05690                 return false;
05691         }
05692 }//setCon
05693 
05694 bool InitConstraintValues::setCon(int numberOfCon, int *idx, double *value)
05695 {       
05696         if (this->con != NULL)
05697                 return false;
05698                 
05699         if (numberOfCon < 0)
05700                 return false;
05701 
05702         this->numberOfCon = numberOfCon;
05703         if (numberOfCon == 0)
05704                 return true;
05705 
05706         this->con = new InitConValue*[numberOfCon];
05707          
05708         int  i;
05709         for (i = 0; i < numberOfCon; i++)
05710         {
05711                 this->con[i] = new InitConValue();
05712                 this->con[i]->idx = idx[i];
05713                 this->con[i]->value = value[i];
05714         }
05715         return true;
05716 }//setObj
05717 
05718 
05719 
05726 bool InitConstraintValues::addCon(int idx, double value)
05727 {       try
05728         {       int nopt; int i;
05729                 if (idx < 0)
05730                         throw ErrorClass( "the index of a constraint cannot be negative." );
05731 
05732                 if (this->con == NULL) 
05733                         nopt = 0;
05734                 else
05735                         nopt = this->numberOfCon;
05736         
05737                 InitConValue** temp = new InitConValue*[nopt+1];  //Allocate the new pointers
05738                 for (i = 0; i < nopt; i++)
05739                         temp[i] = this->con[i];  //copy the pointers
05740 
05741                 delete[] this->con; //delete old pointers
05742         
05743 //      add in the new element
05744                 temp[ nopt] = new InitConValue();
05745 
05746                 temp[ nopt]->idx = idx;
05747                 temp[ nopt]->value = value;
05748 
05749                 this->con = temp;   //hook the new pointers into the data structure
05750                 this->numberOfCon = ++nopt;
05751 
05752                 return true;
05753         }
05754         catch(const ErrorClass& eclass)
05755         {       cout << eclass.errormsg << endl;
05756                 return false;
05757         }
05758 }//addCon
05759 
05766 bool InitDualVariableValues::setCon(int numberOfCon, InitDualVarValue **con)
05767 {       try
05768         {       if (this->con != NULL)
05769                         throw ErrorClass( "InitDualVarValue array previously used.");
05770                 
05771                 if (numberOfCon < 0)
05772                         throw ErrorClass( "length of con array cannot be negative.");
05773 
05774                 this->numberOfCon = numberOfCon;
05775                 if (numberOfCon == 0)
05776                         return true;
05777 
05778                 this->con = new InitDualVarValue*[numberOfCon];
05779          
05780                 int  i;
05781                 for (i = 0; i < numberOfCon; i++)
05782                 {        this->con[i] = new InitDualVarValue();
05783                         *this->con[i] = *con[i];
05784                 }
05785                 return true;
05786         }
05787         catch(const ErrorClass& eclass)
05788         {       cout << eclass.errormsg << endl;
05789                 return false;
05790         }
05791 }//setCon
05792 
05793 bool InitDualVariableValues::setCon(int numberOfCon, int *idx, double *lbValue, double *ubValue)
05794 {       
05795         if (this->con != NULL)
05796                 return false;
05797                 
05798         if (numberOfCon < 0)
05799                 return false;
05800 
05801         this->numberOfCon = numberOfCon;
05802         if (numberOfCon == 0)
05803                 return true;
05804 
05805         this->con = new InitDualVarValue*[numberOfCon];
05806          
05807         int  i;
05808         for (i = 0; i < numberOfCon; i++)
05809         {
05810                 this->con[i] = new InitDualVarValue();
05811                 this->con[i]->idx = idx[i];
05812                 this->con[i]->lbDualValue = lbValue[i];
05813                 this->con[i]->ubDualValue = ubValue[i];
05814         }
05815         return true;
05816 }//setCon
05817 
05818 
05826 bool InitDualVariableValues::addCon(int idx, double lbDualValue, double ubDualValue)
05827 {       try
05828         {       int nopt; int i;
05829                 if (idx < 0)
05830                         throw ErrorClass( "the index of a constraint cannot be negative." );
05831 
05832                 if (this->con == NULL) 
05833                         nopt = 0;
05834                 else
05835                         nopt = this->numberOfCon;
05836         
05837                 InitDualVarValue** temp = new InitDualVarValue*[nopt+1];  //Allocate the new pointers
05838                 for (i = 0; i < nopt; i++)
05839                         temp[i] = this->con[i];  //copy the pointers
05840 
05841                 delete[] this->con; //delete old pointers
05842         
05843 //      add in the new element
05844                 temp[ nopt] = new InitDualVarValue();
05845 
05846                 temp[ nopt]->idx = idx;
05847                 temp[ nopt]->lbDualValue = lbDualValue;
05848                 temp[ nopt]->ubDualValue = ubDualValue;
05849 
05850                 this->con = temp;   //hook the new pointers into the data structure
05851                 this->numberOfCon = ++nopt;
05852 
05853                 return true;
05854         }
05855         catch(const ErrorClass& eclass)
05856         {       cout << eclass.errormsg << endl;
05857                 return false;
05858         }
05859 }//addCon
05860 
05867 bool OtherConstraintOption::setCon(int numberOfCon, OtherConOption **con)
05868 {       try
05869         {       if (this->con != NULL)
05870                         throw ErrorClass( "OtherConOption array previously used.");
05871                 
05872                 if (numberOfCon < 0)
05873                         throw ErrorClass( "length of <con> array cannot be negative.");
05874 
05875                 this->numberOfCon = numberOfCon;
05876                 if (numberOfCon == 0)
05877                         return true;
05878 
05879                 this->con = new OtherConOption*[numberOfCon];
05880          
05881                 int  i;
05882                 for (i = 0; i < numberOfCon; i++)
05883                 {        this->con[i] = new OtherConOption();
05884                         *this->con[i] = *con[i];
05885                 }
05886                 return true;
05887         }
05888         catch(const ErrorClass& eclass)
05889         {       cout << eclass.errormsg << endl;
05890                 return false;
05891         }
05892 }//setCon
05893 
05902 bool OtherConstraintOption::addCon(int idx, std::string value, std::string lbValue, std::string ubValue)
05903 {       try
05904         {       int nopt; int i;
05905                 if (idx < 0)
05906                         throw ErrorClass( "the index of a variable cannot be negative." );
05907 
05908                 if (this->con == NULL) 
05909                         nopt = 0;
05910                 else
05911                         nopt = this->numberOfCon;
05912         
05913                 OtherConOption** temp = new OtherConOption*[nopt+1];  //Allocate the new pointers
05914                 for (i = 0; i < nopt; i++)
05915                         temp[i] = this->con[i];  //copy the pointers
05916 
05917                 delete[] this->con; //delete old pointers
05918         
05919 //      add in the new element
05920                 temp[ nopt] = new OtherConOption();
05921 
05922                 temp[ nopt]->idx = idx;
05923                 temp[ nopt]->value = value;
05924                 temp[ nopt]->lbValue = lbValue;
05925                 temp[ nopt]->ubValue = ubValue;
05926 
05927                 this->con = temp;   //hook the new pointers into the data structure
05928                 this->numberOfCon = ++nopt;
05929 
05930                 return true;
05931         }
05932         catch(const ErrorClass& eclass)
05933         {       cout << eclass.errormsg << endl;
05934                 return false;
05935         }
05936 }//addCon
05937 
05944 bool ConstraintOption::setOther(int numberOfOptions, OtherConstraintOption  **other)
05945 {       try
05946         {       if (this->other != NULL)
05947                         throw ErrorClass( "otherConstraintOptions array previously used.");
05948                 
05949                 if (numberOfOptions < 0)
05950                         throw ErrorClass( "length of <other> array cannot be negative.");
05951 
05952                 this->numberOfOtherConstraintOptions = numberOfOptions;
05953                 if (numberOfOptions == 0)
05954                         return true;
05955 
05956                 this->other = new OtherConstraintOption*[numberOfOptions];
05957          
05958                 int  i, j;
05959                 for (i = 0; i < numberOfOptions; i++)
05960                 {       this->other[i] = new OtherConstraintOption();
05961                         this->other[i]->name        = other[i]->name;
05962                         this->other[i]->value       = other[i]->value;
05963                         this->other[i]->solver      = other[i]->solver;
05964                         this->other[i]->category    = other[i]->category;
05965                         this->other[i]->type        = other[i]->type;
05966                         this->other[i]->description = other[i]->description;
05967 
05968                         if (other[i]->numberOfCon < 0)
05969                                 throw ErrorClass( "the number of constraints in otherConstraintOption cannot be negative.");
05970 
05971                         this->other[i]->numberOfCon = other[i]->numberOfCon;
05972 
05973                         if (other[i]->numberOfCon > 0) 
05974                         {
05975                                 this->other[i]->con = new OtherConOption*[other[i]->numberOfCon];
05976                                 for (j = 0; j < other[i]->numberOfCon; j++)
05977                                 {        this->other[i]->con[j] = new OtherConOption();
05978                                         *this->other[i]->con[j] = *other[i]->con[j];
05979                                 }
05980                         }
05981 
05982                         this->other[i]->numberOfEnumerations = other[i]->numberOfEnumerations;
05983 
05984                         if (this->other[i]->numberOfEnumerations > 0)
05985                         {       
05986                                 this->other[i]->enumeration = new OtherOptionEnumeration*[this->other[i]->numberOfEnumerations];
05987                                 for (j = 0; j < this->other[i]->numberOfEnumerations; j++)
05988                                 {
05989                                         this->other[i]->enumeration[j]  = new OtherOptionEnumeration();
05990                                         this->other[i]->enumeration[j]->setOtherOptionEnumeration(
05991                                                 other[i]->enumeration[j]->value, 
05992                                                 other[i]->enumeration[j]->description, 
05993                                                 other[i]->enumeration[j]->el, 
05994                                                 other[i]->enumeration[j]->numberOfEl);
05995                                 }
05996                         }
05997 
05998                 }
05999                 return true;
06000         }
06001         catch(const ErrorClass& eclass)
06002         {       cout << eclass.errormsg << endl;
06003                 return false;
06004         }
06005 }//setOther
06006 
06012 bool ConstraintOption::addOther(OtherConstraintOption *other)
06013 {       try
06014         {       int nopt, i, j;
06015                 if (this->other == NULL) 
06016                         nopt = 0;
06017                 else
06018                         nopt = this->numberOfOtherConstraintOptions;
06019         
06020                 OtherConstraintOption** temp = new OtherConstraintOption*[nopt+1];  //Allocate the new pointers
06021                 for (i = 0; i < nopt; i++)
06022                         temp[i] = this->other[i];  //copy the pointers
06023 
06024                 delete[] this->other; //delete old pointers
06025         
06026 //      add in the new element
06027          temp[ nopt] = new OtherConstraintOption();
06028                 temp[ nopt]->name        = other->name;
06029                 temp[ nopt]->value       = other->value;
06030                 temp[ nopt]->solver      = other->solver;
06031                 temp[ nopt]->category    = other->category;
06032                 temp[ nopt]->type        = other->type;
06033                 temp[ nopt]->description = other->description;
06034 
06035                 if (other->numberOfCon < 0)
06036                         throw ErrorClass( "the number of constraints in otherConstraintOption cannot be negative.");
06037 
06038                 temp[ nopt]->numberOfCon = other->numberOfCon;
06039                 temp[ nopt]->numberOfEnumerations = other->numberOfEnumerations;
06040 
06041                 if (other->numberOfCon > 0)
06042                 {       
06043                         temp[ nopt]->con = new OtherConOption*[other->numberOfCon];
06044                         for (j = 0; j < other->numberOfCon; j++)
06045                         {
06046                                  temp[ nopt]->con[j] = new OtherConOption();
06047                                 *temp[ nopt]->con[j] = *other->con[j];
06048                         }
06049                 }
06050 
06051                 if (other->numberOfEnumerations < 0)
06052                         throw ErrorClass( "the number of enumerations in otherObjectiveOption cannot be negative.");
06053 
06054                 if (other->numberOfEnumerations > 0)
06055                 {       
06056                         temp[ nopt]->enumeration = new OtherOptionEnumeration*[other->numberOfEnumerations];
06057                         for (j = 0; j < other->numberOfEnumerations; j++)
06058                         {
06059                                 temp[ nopt]->enumeration[j]  = new OtherOptionEnumeration();
06060                                 temp[ nopt]->enumeration[j]->setOtherOptionEnumeration(
06061                                         other->enumeration[j]->value, 
06062                                         other->enumeration[j]->description, 
06063                                         other->enumeration[j]->el, 
06064                                         other->enumeration[j]->numberOfEl);
06065                         }
06066                 }
06067 
06068                 this->other = temp;   //hook the new pointers into the data structure
06069                 this->numberOfOtherConstraintOptions = ++nopt;
06070 
06071                 return true;
06072         }
06073         catch(const ErrorClass& eclass)
06074         {       cout << eclass.errormsg << endl;
06075                 return false;
06076         }
06077 }//addOther
06078 
06085 bool SolverOptions::setSolverOptions(int numberOfOptions, SolverOption **solverOption)
06086 {       try
06087         {       if (this->solverOption != NULL)
06088                         throw ErrorClass( "solverOptions array previously used.");
06089                 
06090                 if (numberOfOptions < 0)
06091                         throw ErrorClass( "length of <solverOption> array cannot be negative.");
06092 
06093                 this->numberOfSolverOptions = numberOfOptions;
06094                 if (numberOfOptions == 0)
06095                         return true;
06096 
06097                 this->solverOption = new SolverOption*[numberOfOptions];
06098          
06099                 int  i;
06100                 for (i = 0; i < numberOfOptions; i++)
06101                 {
06102                         this->solverOption[i] = new SolverOption();
06103 
06104                         this->solverOption[i]->numberOfItems = solverOption[i]->numberOfItems;
06105                         this->solverOption[i]->name = solverOption[i]->name;
06106                         this->solverOption[i]->value = solverOption[i]->value;
06107                         this->solverOption[i]->solver = solverOption[i]->solver;
06108                         this->solverOption[i]->category = solverOption[i]->category;
06109                         this->solverOption[i]->type = solverOption[i]->type;
06110                         this->solverOption[i]->description = solverOption[i]->description;
06111 
06112                         if (solverOption[i]->numberOfItems > 0)
06113                         {
06114                                 this->solverOption[i]->item = new std::string[solverOption[i]->numberOfItems];
06115                                 for (int j=0; j<solverOption[i]->numberOfItems; j++)
06116                                         this->solverOption[i]->item[j] = solverOption[i]->item[j];
06117                         }
06118                 }
06119                 return true;
06120         }
06121         catch(const ErrorClass& eclass)
06122         {       cout << eclass.errormsg << endl;
06123                 return false;
06124         }
06125 }//setSolverOption
06126 
06137 bool SolverOptions::addSolverOption(std::string name, std::string value, std::string solver, 
06138                  std::string category, std::string type, std::string description)
06139 {       try
06140         {
06141                 int nopt; int i;
06142                 if (name.empty() )
06143                         throw ErrorClass( "the name of a solver option cannot be empty." );
06144 
06145                 if (this->solverOption == NULL) 
06146                         nopt = 0;
06147                 else
06148                         nopt = this->numberOfSolverOptions;
06149         
06150                 SolverOption** temp = new SolverOption*[nopt+1];  //Allocate the new pointers
06151                 for (i = 0; i < nopt; i++)
06152                         temp[i] = this->solverOption[i];  //copy the pointers
06153 
06154                 delete[] this->solverOption; //delete old pointers
06155         
06156 //      add in the new element
06157                 temp[ nopt] = new SolverOption();
06158 
06159                 temp[ nopt]->numberOfItems = 0;
06160                 temp[ nopt]->name = name;
06161                 temp[ nopt]->value = value;
06162                 temp[ nopt]->solver = solver;
06163                 temp[ nopt]->type = type;
06164                 temp[ nopt]->category = category;
06165                 temp[ nopt]->description = description;
06166 
06167                 this->solverOption = temp;   //hook the new pointers into the data structure
06168                 this->numberOfSolverOptions = ++nopt;
06169 
06170                 return true;
06171         }
06172         catch(const ErrorClass& eclass)
06173         {       cout << eclass.errormsg << endl;
06174                 return false;
06175         }
06176 }//addSolverOption
06177 
06182 bool OSOption::setOptionHeader(std::string name, std::string source, 
06183                            std::string description, std::string fileCreator, std::string licence)
06184 {
06185         if (this->optionHeader == NULL) 
06186                 this->optionHeader = new GeneralFileHeader();
06187         return this->optionHeader->setHeader(name, source, description, fileCreator, licence);
06188 }// end of OSOption::setOptionHeader
06189 
06194 bool OSOption::setServiceURI( std::string serviceURI)
06195 {
06196         if (this->general == NULL) 
06197                 this->general = new GeneralOption();
06198         this->general->serviceURI = serviceURI;
06199         return true;
06200 }//setServiceURI
06201 
06202 bool OSOption::setServiceName( std::string serviceName)
06203 {
06204         if (this->general == NULL) 
06205                 this->general = new GeneralOption();
06206         this->general->serviceName = serviceName;
06207         return true;
06208 }//setServiceName
06209 
06210 bool OSOption::setInstanceName( std::string instanceName)
06211 {
06212         if (this->general == NULL) 
06213                 this->general = new GeneralOption();
06214         this->general->instanceName = instanceName;
06215         return true;
06216 }//setInstanceName
06217 
06218 bool OSOption::setInstanceLocation( std::string instanceLocation)
06219 {
06220         if (this->general == NULL) 
06221                 this->general = new GeneralOption();
06222         if (this->general->instanceLocation == NULL) 
06223                 this->general->instanceLocation = new InstanceLocationOption();
06224         this->general->instanceLocation->value = instanceLocation;
06225         return true;
06226 }//setInstanceLocation
06227 
06228 bool OSOption::setInstanceLocation( std::string instanceLocation, std::string locationType)
06229 {
06230         if (verifyLocationType(locationType) == 0)
06231                 return false;
06232 
06233         if (this->general == NULL) 
06234                 this->general = new GeneralOption();
06235         if (this->general->instanceLocation == NULL) 
06236                 this->general->instanceLocation = new InstanceLocationOption();
06237         this->general->instanceLocation->value = instanceLocation;
06238         this->general->instanceLocation->locationType = locationType;
06239         return true;
06240 }//setInstanceLocation
06241 
06242 bool OSOption::setInstanceLocationType( std::string locationType)
06243 {
06244         try
06245         {       if (this->general == NULL) 
06246                         this->general = new GeneralOption();
06247                 if (this->general->instanceLocation == NULL) 
06248                         this->general->instanceLocation = new InstanceLocationOption();
06249                 
06250                 if (verifyLocationType(locationType) == 0)
06251                         return false;
06252 
06253                 this->general->instanceLocation->locationType = locationType;
06254                 return true;
06255         }
06256         catch(const ErrorClass& eclass)
06257         {       cout << eclass.errormsg << endl;
06258                 return false;
06259         }
06260 }//setLocationType
06261 
06262 bool OSOption::setJobID( std::string jobID)
06263 {
06264         if (this->general == NULL) 
06265                 this->general = new GeneralOption();
06266         this->general->jobID = jobID;
06267         return true;
06268 }//setJobID
06269 
06270 bool OSOption::setSolverToInvoke( std::string solverToInvoke)
06271 {
06272         if (this->general == NULL) 
06273                 this->general = new GeneralOption();
06274         this->general->solverToInvoke = solverToInvoke;
06275         return true;
06276 }//setSolverToInvoke
06277 
06278 bool OSOption::setLicense( std::string license)
06279 {
06280         if (this->general == NULL) 
06281                 this->general = new GeneralOption();
06282         this->general->license = license;
06283         return true;
06284 }//setLicense
06285 
06286 bool OSOption::setUserName( std::string userName)
06287 {
06288         if (this->general == NULL) 
06289                 this->general = new GeneralOption();
06290         this->general->userName = userName;
06291         return true;
06292 }//setUserName
06293 
06294 bool OSOption::setPassword( std::string password)
06295 {
06296         if (this->general == NULL) 
06297                 this->general = new GeneralOption();
06298         this->general->password = password;
06299         return true;
06300 }//setPassword
06301 
06302 bool OSOption::setContact( std::string contact)
06303 {
06304         if (this->general == NULL) 
06305                 this->general = new GeneralOption();
06306         if (this->general->contact == NULL) 
06307                 this->general->contact = new ContactOption();
06308         this->general->contact->value = contact;
06309         return true;
06310 }//setContact
06311 
06312 bool OSOption::setContact(std::string contact,std::string transportType)
06313 {
06314         if (verifyTransportType(transportType) == 0)
06315                 return false;
06316 
06317         if (this->general == NULL) 
06318                 this->general = new GeneralOption();
06319         if (this->general->contact == NULL) 
06320                 this->general->contact = new ContactOption();
06321         this->general->contact->value = contact;
06322         this->general->contact->transportType = transportType;
06323         return true;
06324 }//setContact
06325 
06326 bool OSOption::setContactTransportType( std::string transportType)
06327 {
06328         try
06329         {       if (this->general == NULL) 
06330                         this->general = new GeneralOption();
06331                 if (this->general->contact == NULL) 
06332                         this->general->contact = new ContactOption();
06333                 
06334                 if (verifyTransportType(transportType) == 0)
06335                         throw ErrorClass( "transport type not recognized.");
06336 
06337                 this->general->contact->transportType = transportType;
06338                 return true;
06339         }
06340         catch(const ErrorClass& eclass)
06341         {       cout << eclass.errormsg << endl;
06342                 return false;
06343         }
06344 }//setContactTransportType
06345 
06346 bool OSOption::setOtherGeneralOptions(int numberOfOptions, OtherOption** other)
06347 {
06348         if (this->general == NULL) 
06349                 this->general = new GeneralOption();
06350         if (this->general->otherOptions == NULL) 
06351                 this->general->otherOptions = new OtherOptions();
06352         else
06353         {       int i;
06354                 for (i = 0; i < this->general->otherOptions->numberOfOtherOptions; i++)
06355                         delete this->general->otherOptions->other[i];
06356                 delete[] this->general->otherOptions->other;
06357                 this->general->otherOptions->other = NULL;
06358         }
06359         return this->general->otherOptions->setOther(numberOfOptions, other);
06360 }//setOtherGeneralOptions
06361 
06362 bool OSOption::setAnOtherGeneralOption(std::string name, std::string value, std::string description)
06363 {
06364         if (this->general == NULL) 
06365                 this->general = new GeneralOption();
06366         if (this->general->otherOptions == NULL) 
06367                 this->general->otherOptions = new OtherOptions();
06368         return this->general->otherOptions->addOther(name, value, description);
06369 }//setAnOtherGeneralOption
06370 
06371 
06372 
06377 bool OSOption::setMinDiskSpace(std::string unit, std::string description, double value)
06378 {
06379         if (verifyStorageUnit(unit) == 0)
06380                 return false;
06381 
06382         if (this->system == NULL) 
06383                 this->system = new SystemOption();
06384         if (this->system->minDiskSpace == NULL)
06385                 this->system->minDiskSpace = new StorageCapacity();
06386         this->system->minDiskSpace->unit = unit;
06387         this->system->minDiskSpace->value = value;
06388         this->system->minDiskSpace->description = description;
06389         return true;
06390 }//setMinDiskSpace
06391 
06392 bool OSOption::setMinDiskSpace(double value)
06393 {       if (this->system == NULL) 
06394                 this->system = new SystemOption();
06395         if (this->system->minDiskSpace == NULL)
06396                 this->system->minDiskSpace = new StorageCapacity();
06397         this->system->minDiskSpace->value = value;
06398         return true;
06399 }//setMinDiskSpace
06400 
06401 bool OSOption::setMinDiskSpaceUnit(std::string unit)
06402 {       try
06403         {       if (this->system == NULL) 
06404                         this->system = new SystemOption();
06405                 if (this->system->minDiskSpace == NULL)
06406                         this->system->minDiskSpace = new StorageCapacity();
06407                 
06408                 if (verifyStorageUnit(unit) == 0)
06409                         throw ErrorClass( "disk space unit not recognized.");
06410 
06411                 this->system->minDiskSpace->unit = unit;
06412                 return true;
06413         }
06414         catch(const ErrorClass& eclass)
06415         {       cout << eclass.errormsg << endl;
06416                 return false;
06417         }
06418 }//setMinDiskSpaceUnit
06419 
06420 bool OSOption::setMinMemorySize(std::string unit, std::string description, double value)
06421 {
06422         if (verifyStorageUnit(unit) == 0)
06423                 return false;
06424 
06425         if (this->system == NULL) 
06426                 this->system = new SystemOption();
06427         if (this->system->minMemorySize == NULL)
06428                 this->system->minMemorySize = new StorageCapacity();
06429         this->system->minMemorySize->unit = unit;
06430         this->system->minMemorySize->value = value;
06431         this->system->minMemorySize->description = description;
06432         return true;
06433 }//setMinDiskSpace
06434 
06435 bool OSOption::setMinMemorySize(double value)
06436 {       if (this->system == NULL) 
06437                 this->system = new SystemOption();
06438         if (this->system->minMemorySize == NULL)
06439                 this->system->minMemorySize = new StorageCapacity();
06440         this->system->minMemorySize->value = value;
06441         return true;
06442 }//setMinMemorySize
06443 
06444 bool OSOption::setMinMemoryUnit(std::string unit)
06445 {       try
06446         {       if (this->system == NULL) 
06447                         this->system = new SystemOption();
06448                 if (this->system->minMemorySize == NULL)
06449                         this->system->minMemorySize = new StorageCapacity();
06450                 
06451                 if (verifyStorageUnit(unit) == 0)
06452                         throw ErrorClass( "memory size unit not recognized.");
06453 
06454                 this->system->minMemorySize->unit = unit;
06455                 return true;
06456         }
06457         catch(const ErrorClass& eclass)
06458         {       cout << eclass.errormsg << endl;
06459                 return false;
06460         }
06461 }//setMinMemoryUnit
06462 
06463 bool OSOption::setMinCPUSpeed(double value)
06464 {       if (this->system == NULL) 
06465                 this->system = new SystemOption();
06466         if (this->system->minCPUSpeed == NULL)
06467                 this->system->minCPUSpeed = new CPUSpeed();
06468         this->system->minCPUSpeed->value = value;
06469         return true;
06470 }//setMinCPUSpeed
06471 
06472 bool OSOption::setMinCPUSpeed(std::string unit, std::string description, double value)
06473 {
06474         if (verifyCPUSpeedUnit(unit) == 0)
06475                 return false;
06476 
06477         if (this->system == NULL) 
06478                 this->system = new SystemOption();
06479         if (this->system->minCPUSpeed == NULL)
06480                 this->system->minCPUSpeed = new CPUSpeed();
06481         this->system->minCPUSpeed->unit = unit;
06482         this->system->minCPUSpeed->value = value;
06483         this->system->minCPUSpeed->description = description;
06484         return true;
06485 }//setMinCPUSpeed
06486 
06487 bool OSOption::setMinCPUSpeedUnit(std::string unit)
06488 {       try
06489         {       if (this->system == NULL) 
06490                         this->system = new SystemOption();
06491                 if (this->system->minCPUSpeed == NULL)
06492                         this->system->minCPUSpeed = new CPUSpeed();
06493                 
06494                 if (verifyCPUSpeedUnit(unit) == 0)
06495                         throw ErrorClass( "CPU speed unit not recognized.");
06496 
06497                 this->system->minCPUSpeed->unit = unit;
06498                 return true;
06499         }
06500         catch(const ErrorClass& eclass)
06501         {       cout << eclass.errormsg << endl;
06502                 return false;
06503         }
06504 }//setMinCPUSpeedUnit
06505 
06506 bool OSOption::setMinCPUNumber(int number)
06507 {
06508         if (this->system == NULL) 
06509                 this->system = new SystemOption();
06510         if (this->system->minCPUNumber == NULL) 
06511                 this->system->minCPUNumber = new CPUNumber();
06512         this->system->minCPUNumber->value = number;
06513         return true;
06514 }//setMinCPUNumber
06515 
06516 bool OSOption::setMinCPUNumber(int number, std::string description)
06517 {
06518         if (this->system == NULL) 
06519                 this->system = new SystemOption();
06520         if (this->system->minCPUNumber == NULL) 
06521                 this->system->minCPUNumber = new CPUNumber();
06522         this->system->minCPUNumber->value = number;
06523         this->system->minCPUNumber->description = description;
06524         return true;
06525 }//setMinCPUNumber
06526 
06527 bool OSOption::setOtherSystemOptions(int numberOfOptions, OtherOption** other)
06528 {       if (this->system == NULL) 
06529                 this->system = new SystemOption();
06530         if (this->system->otherOptions == NULL) 
06531                 this->system->otherOptions = new OtherOptions();
06532         else
06533         {       int i;
06534                 for (i = 0; i < this->system->otherOptions->numberOfOtherOptions; i++)
06535                         delete this->system->otherOptions->other[i];
06536                 delete[] this->system->otherOptions->other;
06537                 this->system->otherOptions->other = NULL;
06538                 this->system->otherOptions->numberOfOtherOptions = 0;
06539         }
06540         return this->system->otherOptions->setOther(numberOfOptions, other);
06541 }//setOtherSystemOptions
06542 
06543 bool OSOption::setAnOtherSystemOption(std::string name, std::string value, std::string description)
06544 {       if (this->system == NULL) 
06545                 this->system = new SystemOption();
06546         if (this->system->otherOptions == NULL) 
06547                 this->system->otherOptions = new OtherOptions();
06548         return this->system->otherOptions->addOther(name, value, description);
06549 }//setAnOtherSystemOption
06550 
06551 
06556 bool OSOption::setServiceType( std::string serviceType)
06557 {       try
06558         {       if (this->service == NULL) 
06559                         this->service = new ServiceOption();
06560                 
06561                 if (verifyServiceType(serviceType) == 0)
06562                         throw ErrorClass( "service type not recognized.");
06563 
06564                 this->service->type = serviceType;
06565                 return true;
06566         }
06567         catch(const ErrorClass& eclass)
06568         {       cout << eclass.errormsg << endl;
06569                 return false;
06570         }
06571 }//setServiceType
06572 
06573 bool OSOption::setOtherServiceOptions(int numberOfOptions, OtherOption** other)
06574 {       if (this->service == NULL) 
06575                 this->service = new ServiceOption();
06576         if (this->service->otherOptions == NULL) 
06577                 this->service->otherOptions = new OtherOptions();
06578         else
06579         {       int i;
06580                 for (i = 0; i < this->service->otherOptions->numberOfOtherOptions; i++)
06581                         delete this->service->otherOptions->other[i];
06582                 delete[] this->service->otherOptions->other;
06583                 this->service->otherOptions->other = NULL;
06584         }
06585         return this->service->otherOptions->setOther(numberOfOptions, other);
06586 }//setOtherServiceOptions
06587 
06588 bool OSOption::setAnOtherServiceOption(std::string name, std::string value, std::string description)
06589 {       if (this->service == NULL) 
06590                 this->service = new ServiceOption();
06591         if (this->service->otherOptions == NULL) 
06592                 this->service->otherOptions = new OtherOptions();
06593         return this->service->otherOptions->addOther(name, value, description);
06594 }//setAnOtherServiceOption
06595 
06600 bool OSOption::setMaxTime(double value)
06601 {       if (this->job == NULL) 
06602                 this->job = new JobOption();
06603         if (this->job->maxTime == NULL)
06604                 this->job->maxTime = new TimeSpan();
06605         this->job->maxTime->value = value;
06606         return true;
06607 }//setMaxTime
06608 
06609 bool OSOption::setMaxTime(double value, std::string unit)
06610 {
06611         if (verifyTimeUnit(unit) == 0)
06612                 return false;
06613 
06614         if (this->job == NULL) 
06615                 this->job = new JobOption();
06616         if (this->job->maxTime == NULL)
06617                 this->job->maxTime = new TimeSpan();
06618         this->job->maxTime->value = value;
06619         this->job->maxTime->unit = unit;
06620         return true;
06621 }//setMaxTime
06622 
06623 bool OSOption::setMaxTimeUnit(std::string unit)
06624 {       try
06625         {       if (this->job == NULL) 
06626                         this->job = new JobOption();
06627                 if (this->job->maxTime == NULL)
06628                         this->job->maxTime = new TimeSpan();
06629                 
06630                 if (verifyTimeUnit(unit) == 0)
06631                         throw ErrorClass( "time unit not recognized.");
06632 
06633                 this->job->maxTime->unit = unit;
06634                 return true;
06635         }
06636         catch(const ErrorClass& eclass)
06637         {       cout << eclass.errormsg << endl;
06638                 return false;
06639         }
06640 }//setMaxTimeUnit
06641 
06642 bool OSOption::setRequestedStartTime(std::string time)
06643 {       if (this->job == NULL) 
06644                 this->job = new JobOption();
06645         this->job->requestedStartTime = time;
06646         return true;
06647 }//setRequestedStartTime
06648 
06649 
06650 bool OSOption::setJobDependencies(int numberOfDependencies, std::string* jobDependencies)
06651 {       if (this->job == NULL) 
06652                 this->job = new JobOption();
06653         if (this->job->dependencies == NULL) 
06654                 this->job->dependencies = new JobDependencies();
06655         else 
06656                 delete[] this->job->dependencies->jobID;
06657         this->job->dependencies->jobID = NULL;
06658         return this->job->dependencies->setJobID(numberOfDependencies, jobDependencies);
06659 }//setJobDependencies
06660 
06661 bool OSOption::setAnotherJobDependency(std::string jobID)
06662 {       if (this->job == NULL) 
06663                 this->job = new JobOption();
06664         if (this->job->dependencies == NULL) 
06665                 this->job->dependencies = new JobDependencies();
06666         return this->job->dependencies->addJobID(jobID);
06667 }//setAnotherJobDependency
06668 
06669 
06670 bool OSOption::setRequiredDirectories(int numberOfPaths, std::string* paths)
06671 {       if (this->job == NULL) 
06672                 this->job = new JobOption();
06673         if (this->job->requiredDirectories == NULL) 
06674                 this->job->requiredDirectories = new DirectoriesAndFiles();
06675         else
06676                 delete[] this->job->requiredDirectories->path;
06677         this->job->requiredDirectories->path = NULL;
06678         return this->job->requiredDirectories->setPath(numberOfPaths, paths);
06679 }//setRequiredDirectories
06680 
06681 bool OSOption::setAnotherRequiredDirectory(std::string path)
06682 {       if (this->job == NULL) 
06683                 this->job = new JobOption();
06684         if (this->job->requiredDirectories == NULL) 
06685                 this->job->requiredDirectories = new DirectoriesAndFiles();
06686         return this->job->requiredDirectories->addPath(path);
06687 }//setAnotherRequiredDirectory
06688 
06689 
06690 bool OSOption::setRequiredFiles(int numberOfPaths, std::string* paths)
06691 {       if (this->job == NULL) 
06692                 this->job = new JobOption();
06693         if (this->job->requiredFiles == NULL) 
06694                 this->job->requiredFiles = new DirectoriesAndFiles();
06695         else
06696                 delete[] this->job->requiredFiles->path;
06697         this->job->requiredFiles->path = NULL;
06698         return this->job->requiredFiles->setPath(numberOfPaths, paths);
06699 }//setRequiredFiles
06700 
06701 bool OSOption::setAnotherRequiredFile(std::string path)
06702 {       if (this->job == NULL) 
06703                 this->job = new JobOption();
06704         if (this->job->requiredFiles == NULL) 
06705                 this->job->requiredFiles = new DirectoriesAndFiles();
06706         return this->job->requiredFiles->addPath(path);
06707 }//setAnotherRequiredFile
06708 
06709 
06710 bool OSOption::setDirectoriesToMake(int numberOfPaths, std::string* paths)
06711 {       if (this->job == NULL) 
06712                 this->job = new JobOption();
06713         if (this->job->directoriesToMake == NULL) 
06714                 this->job->directoriesToMake = new DirectoriesAndFiles();
06715         else
06716                 delete[] this->job->directoriesToMake->path;
06717         this->job->directoriesToMake->path = NULL;
06718         return this->job->directoriesToMake->setPath(numberOfPaths, paths);
06719 }//setDirectoriesToMake
06720 
06721 bool OSOption::setAnotherDirectoryToMake(std::string path)
06722 {       if (this->job == NULL) 
06723                 this->job = new JobOption();
06724         if (this->job->directoriesToMake == NULL) 
06725                 this->job->directoriesToMake = new DirectoriesAndFiles();
06726         return this->job->directoriesToMake->addPath(path);
06727 }//setAnotherDirectoryToMake
06728 
06729 
06730 bool OSOption::setFilesToMake(int numberOfPaths, std::string* paths)
06731 {       if (this->job == NULL) 
06732                 this->job = new JobOption();
06733         if (this->job->filesToMake == NULL) 
06734                 this->job->filesToMake = new DirectoriesAndFiles();
06735         else
06736                 delete[] this->job->filesToMake->path;
06737         this->job->filesToMake->path = NULL;
06738         return this->job->filesToMake->setPath(numberOfPaths, paths);
06739 }//setFilesToMake
06740 
06741 bool OSOption::setAnotherFileToMake(std::string path)
06742 {       if (this->job == NULL) 
06743                 this->job = new JobOption();
06744         if (this->job->filesToMake == NULL) 
06745                 this->job->filesToMake = new DirectoriesAndFiles();
06746         return this->job->filesToMake->addPath(path);
06747 }//setAnotherFileToMake
06748 
06749 bool OSOption::setPathPairs(int object, std::string *from, std::string *to, bool *makeCopy, int numberOfPathPairs)
06750 {
06751         if (numberOfPathPairs < 0) return false;
06752         if (this->job == NULL) 
06753                 this->job = new JobOption();
06754         switch (object)
06755         {
06756                 case ENUM_PATHPAIR_input_dir:
06757                 {
06758                         if (this->job->inputDirectoriesToMove == NULL) 
06759                                 this->job->inputDirectoriesToMove = new PathPairs();
06760                         return this->job->inputDirectoriesToMove->setPathPair(from, to, makeCopy, numberOfPathPairs);
06761                 }
06762                 case ENUM_PATHPAIR_input_file:
06763                 {
06764                         if (this->job->inputFilesToMove == NULL) 
06765                                 this->job->inputFilesToMove = new PathPairs();
06766                         return this->job->inputFilesToMove->setPathPair(from, to, makeCopy, numberOfPathPairs);
06767                 }
06768                 case ENUM_PATHPAIR_output_file:
06769                 {
06770                         if (this->job->outputFilesToMove == NULL) 
06771                                 this->job->outputFilesToMove = new PathPairs();
06772                         return this->job->outputFilesToMove->setPathPair(from, to, makeCopy, numberOfPathPairs);
06773                 }
06774                 case ENUM_PATHPAIR_output_dir:
06775                 {
06776                         if (this->job->outputDirectoriesToMove == NULL) 
06777                                 this->job->outputDirectoriesToMove = new PathPairs();
06778                         return this->job->outputDirectoriesToMove->setPathPair(from, to, makeCopy, numberOfPathPairs);
06779                 }
06780                 default:
06781                         throw ErrorClass("target object not implemented in setPathPairs");
06782         }
06783 
06784 }//setPathPairs
06785 
06786 
06787 bool OSOption::setInputDirectoriesToMove(int numberOfPathPairs, PathPair** pathPair)
06788 {       if (this->job == NULL) 
06789                 this->job = new JobOption();
06790         if (this->job->inputDirectoriesToMove == NULL) 
06791                 this->job->inputDirectoriesToMove = new PathPairs();
06792         else
06793                 delete[] this->job->inputDirectoriesToMove->pathPair;
06794         this->job->inputDirectoriesToMove->pathPair = NULL;
06795         return this->job->inputDirectoriesToMove->setPathPair(numberOfPathPairs, pathPair);
06796 }//setInputDirectoriesToMove
06797 
06798 bool OSOption::setAnotherInputDirectoryToMove(std::string fromPath, std::string toPath, bool makeCopy)
06799 {       if (this->job == NULL) 
06800                 this->job = new JobOption();
06801         if (this->job->inputDirectoriesToMove == NULL) 
06802                 this->job->inputDirectoriesToMove = new PathPairs();
06803         return this->job->inputDirectoriesToMove->addPathPair(fromPath, toPath, makeCopy);
06804 }//setAnotherInputDirectoryToMove
06805 
06806 
06807 bool OSOption::setInputFilesToMove(int numberOfPathPairs, PathPair** pathPair)
06808 {       if (this->job == NULL) 
06809                 this->job = new JobOption();
06810         if (this->job->inputFilesToMove == NULL) 
06811                 this->job->inputFilesToMove = new PathPairs();
06812         else
06813                 delete[] this->job->inputFilesToMove->pathPair;
06814         this->job->inputFilesToMove->pathPair = NULL;
06815         return this->job->inputFilesToMove->setPathPair(numberOfPathPairs, pathPair);
06816 }//setInputFilesToMove
06817 
06818 bool OSOption::setAnotherInputFileToMove(std::string fromPath, std::string toPath, bool makeCopy)
06819 {       if (this->job == NULL) 
06820                 this->job = new JobOption();
06821         if (this->job->inputFilesToMove == NULL) 
06822                 this->job->inputFilesToMove = new PathPairs();
06823         return this->job->inputFilesToMove->addPathPair(fromPath, toPath, makeCopy);
06824 }//setAnotherInputFileToMove
06825 
06826 
06827 bool OSOption::setOutputFilesToMove(int numberOfPathPairs, PathPair** pathPair)
06828 {       if (this->job == NULL) 
06829                 this->job = new JobOption();
06830         if (this->job->outputFilesToMove == NULL) 
06831                 this->job->outputFilesToMove = new PathPairs();
06832         else
06833                 delete[] this->job->outputFilesToMove->pathPair;
06834         this->job->outputFilesToMove->pathPair = NULL;
06835         return this->job->outputFilesToMove->setPathPair(numberOfPathPairs, pathPair);
06836 }//setOutputFilesToMove
06837 
06838 bool OSOption::setAnotherOutputFileToMove(std::string fromPath, std::string toPath, bool makeCopy)
06839 {       if (this->job == NULL) 
06840                 this->job = new JobOption();
06841         if (this->job->outputFilesToMove == NULL) 
06842                 this->job->outputFilesToMove = new PathPairs();
06843         return this->job->outputFilesToMove->addPathPair(fromPath, toPath, makeCopy);
06844 }//setAnotherOutputFileToMove
06845 
06846 
06847 bool OSOption::setOutputDirectoriesToMove(int numberOfPathPairs, PathPair** pathPair)
06848 {       if (this->job == NULL) 
06849                 this->job = new JobOption();
06850         if (this->job->outputDirectoriesToMove == NULL) 
06851                 this->job->outputDirectoriesToMove = new PathPairs();
06852         else
06853                 delete[] this->job->outputDirectoriesToMove->pathPair;
06854         this->job->outputDirectoriesToMove->pathPair = NULL;
06855         return this->job->outputDirectoriesToMove->setPathPair(numberOfPathPairs, pathPair);
06856 }//setOutputDirectoriesToMove
06857 
06858 bool OSOption::setAnotherOutputDirectoryToMove(std::string fromPath, std::string toPath, bool makeCopy)
06859 {       if (this->job == NULL) 
06860                 this->job = new JobOption();
06861         if (this->job->outputDirectoriesToMove == NULL) 
06862                 this->job->outputDirectoriesToMove = new PathPairs();
06863         return this->job->outputDirectoriesToMove->addPathPair(fromPath, toPath, makeCopy);
06864 }//setAnotherOutputDirectoryToMove
06865 
06866 
06867 bool OSOption::setFilesToDelete(int numberOfPaths, std::string* paths)
06868 {       if (this->job == NULL) 
06869                 this->job = new JobOption();
06870         if (this->job->filesToDelete == NULL) 
06871                 this->job->filesToDelete = new DirectoriesAndFiles();
06872         else
06873                 delete[] this->job->filesToDelete->path;
06874         this->job->filesToDelete->path = NULL;
06875         return this->job->filesToDelete->setPath(numberOfPaths, paths);
06876 }//setFilesToDelete
06877 
06878 bool OSOption::setAnotherFileToDelete(std::string path)
06879 {       if (this->job == NULL) 
06880                 this->job = new JobOption();
06881         if (this->job->filesToDelete == NULL) 
06882                 this->job->filesToDelete = new DirectoriesAndFiles();
06883         return this->job->filesToDelete->addPath(path);
06884 }//setAnotherFileToDelete
06885 
06886 
06887 bool OSOption::setDirectoriesToDelete(int numberOfPaths, std::string* paths)
06888 {       if (this->job == NULL) 
06889                 this->job = new JobOption();
06890         if (this->job->directoriesToDelete == NULL) 
06891                 this->job->directoriesToDelete = new DirectoriesAndFiles();
06892         else
06893                 delete[] this->job->directoriesToDelete->path;
06894         this->job->directoriesToDelete->path = NULL;
06895         return this->job->directoriesToDelete->setPath(numberOfPaths, paths);
06896 }//setDirectoriesToDelete
06897 
06898 bool OSOption::setAnotherDirectoryToDelete(std::string path)
06899 {       if (this->job == NULL) 
06900                 this->job = new JobOption();
06901         if (this->job->directoriesToDelete == NULL) 
06902                 this->job->directoriesToDelete = new DirectoriesAndFiles();
06903         return this->job->directoriesToDelete->addPath(path);
06904 }//setAnotherDirectoryToDelete
06905 
06906 
06907 bool OSOption::setProcessesToKill(int numberOfProcesses, std::string* processes)
06908 {       if (this->job == NULL) 
06909                 this->job = new JobOption();
06910         if (this->job->processesToKill == NULL) 
06911                 this->job->processesToKill = new Processes();
06912         else
06913                 delete[] this->job->processesToKill->process;
06914         this->job->processesToKill->process = NULL;
06915         return this->job->processesToKill->setProcess(numberOfProcesses, processes);
06916 }//setProcessesToKill
06917 
06918 bool OSOption::setAnotherProcessToKill(std::string process)
06919 {       if (this->job == NULL) 
06920                 this->job = new JobOption();
06921         if (this->job->processesToKill == NULL) 
06922                 this->job->processesToKill = new Processes();
06923         return this->job->processesToKill->addProcess(process);
06924 }//setAnotherProcessToKill
06925 
06926 
06927 bool OSOption::setOtherJobOptions(int numberOfOptions, OtherOption** other)
06928 {       if (this->job == NULL) 
06929                 this->job = new JobOption();
06930         if (this->job->otherOptions == NULL) 
06931                 this->job->otherOptions = new OtherOptions();
06932         else
06933         {       int i;
06934                 for (i = 0; i < this->job->otherOptions->numberOfOtherOptions; i++)
06935                         delete this->job->otherOptions->other[i];
06936                 delete[] this->job->otherOptions->other;
06937                 this->job->otherOptions->other = NULL;
06938         }
06939         return this->job->otherOptions->setOther(numberOfOptions, other);
06940 }//setOtherJobOptions
06941 
06942 bool OSOption::setAnOtherJobOption(std::string name, std::string value, std::string description)
06943 {       if (this->job == NULL) 
06944                 this->job = new JobOption();
06945         if (this->job->otherOptions == NULL) 
06946                 this->job->otherOptions = new OtherOptions();
06947         return this->job->otherOptions->addOther(name, value, description);
06948 }//setAnOtherJobOption
06949 
06950 
06951 
06952 bool OSOption::setNumberOfVariables(int numberOfVariables)
06953 {       if (this->optimization == NULL) 
06954                 this->optimization = new OptimizationOption();
06955         this->optimization->numberOfVariables = numberOfVariables;
06956         return true;
06957 }//setNumberOfVariables
06958 
06959 bool OSOption::setNumberOfObjectives(int numberOfObjectives)
06960 {       if (this->optimization == NULL) 
06961                 this->optimization = new OptimizationOption();
06962         this->optimization->numberOfObjectives = numberOfObjectives;
06963         return true;
06964 }//setNumberOfObjectives
06965 
06966 bool OSOption::setNumberOfConstraints(int numberOfConstraints)
06967 {       if (this->optimization == NULL) 
06968                 this->optimization = new OptimizationOption();
06969         this->optimization->numberOfConstraints = numberOfConstraints;
06970         return true;
06971 }//setNumberOfConstraints
06972 
06973 
06974 bool OSOption::setInitVarValues(int numberOfVar, int* idx, double* value)
06975 {
06976         if (this->optimization == NULL) 
06977                 this->optimization = new OptimizationOption();
06978         if (this->optimization->variables == NULL) 
06979                 this->optimization->variables = new VariableOption();
06980         if (this->optimization->variables->initialVariableValues != NULL) 
06981                 return false;
06982 
06983         this->optimization->variables->initialVariableValues = new InitVariableValues();
06984 
06985         return this->optimization->variables->initialVariableValues->setVar(numberOfVar, idx, value);
06986 }//setInitVarValues
06987 
06988 
06989 bool OSOption::setInitVarValuesSparse(int numberOfVar, InitVarValue** var)
06990 {       if (this->optimization == NULL) 
06991                 this->optimization = new OptimizationOption();
06992         if (this->optimization->variables == NULL) 
06993                 this->optimization->variables = new VariableOption();
06994         if (this->optimization->variables->initialVariableValues == NULL) 
06995                 this->optimization->variables->initialVariableValues = new InitVariableValues();
06996         else
06997         {       int i;
06998                 for (i = 0; i < this->optimization->variables->initialVariableValues->numberOfVar; i++)
06999                         delete this->optimization->variables->initialVariableValues->var[i];
07000                 delete[] this->optimization->variables->initialVariableValues->var;
07001                 this->optimization->variables->initialVariableValues->var = NULL;
07002         }
07003         return this->optimization->variables->initialVariableValues->setVar(numberOfVar, var);
07004 }//setInitVarValuesSparse
07005 
07006 bool OSOption::setInitVarValuesDense(int numberOfVar, double *value)
07007 {       if (this->optimization == NULL) 
07008                 this->optimization = new OptimizationOption();
07009         if (this->optimization->variables == NULL) 
07010                 this->optimization->variables = new VariableOption();
07011         if (this->optimization->variables->initialVariableValues == NULL) 
07012                 this->optimization->variables->initialVariableValues = new InitVariableValues();
07013         else
07014         {       delete[] this->optimization->variables->initialVariableValues->var;
07015                 this->optimization->variables->initialVariableValues->var = NULL;
07016         }
07017 
07018         int i;
07019         for (i = 0; i < numberOfVar; i++)
07020         {       
07021 //              if (!CoinIsnan(value[i]))
07022                         if (!this->optimization->variables->initialVariableValues->addVar(i, value[i]))
07023                                 return false;
07024         }
07025         return true;
07026 }//setInitVarValuesDense
07027 
07028 bool OSOption::setAnotherInitVarValue(int idx, double value)
07029 {       if (this->optimization == NULL) 
07030                 this->optimization = new OptimizationOption();
07031         if (this->optimization->variables == NULL) 
07032                 this->optimization->variables = new VariableOption();
07033         if (this->optimization->variables->initialVariableValues == NULL) 
07034                 this->optimization->variables->initialVariableValues = new InitVariableValues();
07035         return this->optimization->variables->initialVariableValues->addVar(idx, value);
07036 }//setAnotherInitVarValue
07037 
07038 bool OSOption::setInitVarValuesString(int numberOfVar, int* idx, std::string* value)
07039 {
07040         if (this->optimization == NULL) 
07041                 this->optimization = new OptimizationOption();
07042         if (this->optimization->variables == NULL) 
07043                 this->optimization->variables = new VariableOption();
07044         if (this->optimization->variables->initialVariableValuesString != NULL) 
07045                 return false;
07046 
07047         this->optimization->variables->initialVariableValuesString = new InitVariableValuesString();
07048 
07049         return this->optimization->variables->initialVariableValuesString->setVar(numberOfVar, idx, value);
07050 }//setInitVarValuesString
07051 
07052 bool OSOption::setInitVarValuesStringSparse(int numberOfVar, InitVarValueString** var)
07053 {       if (this->optimization == NULL) 
07054                 this->optimization = new OptimizationOption();
07055         if (this->optimization->variables == NULL) 
07056                 this->optimization->variables = new VariableOption();
07057         if (this->optimization->variables->initialVariableValuesString == NULL) 
07058                 this->optimization->variables->initialVariableValuesString = new InitVariableValuesString();
07059         else
07060         {       int i;
07061                 for (i = 0; i < this->optimization->variables->initialVariableValuesString->numberOfVar; i++)
07062                         delete this->optimization->variables->initialVariableValuesString->var[i];
07063                 delete[] this->optimization->variables->initialVariableValuesString->var;
07064                 this->optimization->variables->initialVariableValuesString->var = NULL;
07065         }
07066         return this->optimization->variables->initialVariableValuesString->setVar(numberOfVar, var);
07067 }//setInitVarValuesStringSparse
07068 
07069 bool OSOption::setInitVarValuesStringDense(int numberOfVar, std::string *value)
07070 {       if (this->optimization == NULL) 
07071                 this->optimization = new OptimizationOption();
07072         if (this->optimization->variables == NULL) 
07073                 this->optimization->variables = new VariableOption();
07074         if (this->optimization->variables->initialVariableValuesString == NULL) 
07075                 this->optimization->variables->initialVariableValuesString = new InitVariableValuesString();
07076         else
07077         {       delete[] this->optimization->variables->initialVariableValuesString->var;
07078                 this->optimization->variables->initialVariableValuesString->var = NULL;
07079         }
07080         int i;
07081         for (i = 0; i < numberOfVar; i++)
07082         {       if (value[i] != "")
07083                         if (!this->optimization->variables->initialVariableValuesString->addVar(i, value[i]))
07084                                 return false;
07085         }
07086                 return true;
07087 }//setInitVarValuesStringDense
07088 
07089 bool OSOption::setAnotherInitVarValueString(int idx, std::string value)
07090 {       if (this->optimization == NULL) 
07091                 this->optimization = new OptimizationOption();
07092         if (this->optimization->variables == NULL) 
07093                 this->optimization->variables = new VariableOption();
07094         if (this->optimization->variables->initialVariableValuesString == NULL) 
07095                 this->optimization->variables->initialVariableValuesString = new InitVariableValuesString();
07096         return this->optimization->variables->initialVariableValuesString->addVar(idx, value);
07097 }//setAnotherInitVarValueString
07098 
07099 bool OSOption::setInitBasisStatus(int object, int status, int *i, int ni)
07100 {
07101         if (optimization == NULL) return false;
07102 
07103         switch (object) 
07104         {
07105                 case ENUM_PROBLEM_COMPONENT_variables:
07106                 {
07107                         if (optimization->variables == NULL)
07108                                 optimization->variables = new VariableOption();
07109                         if (optimization->variables->initialBasisStatus == NULL)
07110                                 optimization->variables->initialBasisStatus = new BasisStatus();
07111                         for (int j=0; j<ni; j++) if (i[j] < 0) return false;
07112                         return optimization->variables->initialBasisStatus->setIntVector(status, i, ni);
07113                 }
07114                 case ENUM_PROBLEM_COMPONENT_objectives: 
07115                 {
07116                         if (optimization->objectives == NULL)
07117                                 optimization->objectives = new ObjectiveOption();
07118                         if (optimization->objectives->initialBasisStatus == NULL)
07119                                 optimization->objectives->initialBasisStatus = new BasisStatus();
07120                         for (int j=0; j<ni; j++) if (i[j] >= 0) return false;
07121                         return optimization->objectives->initialBasisStatus->setIntVector(status, i, ni);
07122                 }
07123                 case ENUM_PROBLEM_COMPONENT_constraints:        
07124                 {
07125                         if (optimization->constraints == NULL)
07126                                 optimization->constraints = new ConstraintOption();
07127                         if (optimization->constraints->initialBasisStatus == NULL)
07128                                 optimization->constraints->initialBasisStatus = new BasisStatus();
07129                         for (int j=0; j<ni; j++) if (i[j] < 0) return false;
07130                         return optimization->constraints->initialBasisStatus->setIntVector(status, i, ni);
07131                 }
07132                 default: 
07133                         throw ErrorClass("target object not implemented in setInitBasisStatus");
07134         }
07135 }//setInitBasisStatus
07136 
07137 bool OSOption::setAnotherInitBasisStatus(int object, int idx, int status)
07138 {
07139         if (optimization == NULL) return false;
07140 
07141         switch (object) 
07142         {
07143                 case ENUM_PROBLEM_COMPONENT_variables:
07144                 {
07145                         if (optimization->variables == NULL)
07146                                 optimization->variables = new VariableOption();
07147                         if (optimization->variables->initialBasisStatus == NULL)
07148                                 optimization->variables->initialBasisStatus = new BasisStatus();
07149                         if (idx < 0) return false;
07150                         return optimization->variables->initialBasisStatus->addIdx(status, idx);
07151                 }
07152                 case ENUM_PROBLEM_COMPONENT_objectives: 
07153                 {
07154                         if (optimization->objectives == NULL)
07155                                 optimization->objectives = new ObjectiveOption();
07156                         if (optimization->objectives->initialBasisStatus == NULL)
07157                                 optimization->objectives->initialBasisStatus = new BasisStatus();
07158                         if (idx >= 0) return false;
07159                         return optimization->objectives->initialBasisStatus->addIdx(status, idx);
07160                 }
07161                 case ENUM_PROBLEM_COMPONENT_constraints:        
07162                 {
07163                         if (optimization->constraints == NULL)
07164                                 optimization->constraints = new ConstraintOption();
07165                         if (optimization->constraints->initialBasisStatus == NULL)
07166                                 optimization->constraints->initialBasisStatus = new BasisStatus();
07167                         if (idx < 0) return false;
07168                         return optimization->constraints->initialBasisStatus->addIdx(status, idx);
07169                 }
07170                 default: 
07171                         throw ErrorClass("target object not implemented in setAnotherInitBasisStatus");
07172         }
07173 }//setAnotherInitBasisStatus
07174 
07175 bool OSOption::setIntegerVariableBranchingWeights(int numberOfVar, int* idx, double* value)
07176 {
07177         if (this->optimization == NULL) 
07178                 this->optimization = new OptimizationOption();
07179         if (this->optimization->variables == NULL) 
07180                 this->optimization->variables = new VariableOption();
07181         if (this->optimization->variables->integerVariableBranchingWeights != NULL) 
07182                 return false;
07183 
07184         this->optimization->variables->integerVariableBranchingWeights = new IntegerVariableBranchingWeights();
07185 
07186         return this->optimization->variables->integerVariableBranchingWeights->setVar(numberOfVar, idx, value);
07187 }//setIntegerVariableBranchingWeights
07188 
07189 bool OSOption::setIntegerVariableBranchingWeightsSparse(int numberOfVar, BranchingWeight** var)
07190 {       if (this->optimization == NULL) 
07191                 this->optimization = new OptimizationOption();
07192         if (this->optimization->variables == NULL) 
07193                 this->optimization->variables = new VariableOption();
07194         if (this->optimization->variables->integerVariableBranchingWeights == NULL) 
07195                 this->optimization->variables->integerVariableBranchingWeights = new IntegerVariableBranchingWeights();
07196         else
07197         {       int i;
07198                 for (i = 0; i < this->optimization->variables->integerVariableBranchingWeights->numberOfVar; i++)
07199                         delete this->optimization->variables->integerVariableBranchingWeights->var[i];
07200                 delete[] this->optimization->variables->integerVariableBranchingWeights->var;
07201                 this->optimization->variables->integerVariableBranchingWeights->var = NULL;
07202         }
07203         return this->optimization->variables->integerVariableBranchingWeights->setVar(numberOfVar, var);
07204 }//setIntegerVariableBranchingWeightsSparse
07205 
07206 bool OSOption::setIntegerVariableBranchingWeightsDense(int numberOfVar, double *value)
07207 {       if (this->optimization == NULL) 
07208                 this->optimization = new OptimizationOption();
07209         if (this->optimization->variables == NULL) 
07210                 this->optimization->variables = new VariableOption();
07211         if (this->optimization->variables->integerVariableBranchingWeights == NULL) 
07212                 this->optimization->variables->integerVariableBranchingWeights = new IntegerVariableBranchingWeights();
07213         else
07214         {       delete[] this->optimization->variables->integerVariableBranchingWeights->var;
07215                 this->optimization->variables->integerVariableBranchingWeights->var = NULL;
07216         }
07217         int i;
07218         for (i = 0; i < numberOfVar; i++)
07219         {
07220 //              if (!CoinIsnan(value[i]))
07221                         if (!this->optimization->variables->integerVariableBranchingWeights->addVar(i, value[i]))
07222                                 return false;
07223         }
07224         return true;
07225 }//setIntegerVariableBranchingWeightsDense
07226 
07227 bool OSOption::setAnotherIntegerVariableBranchingWeight(int idx, double value)
07228 {       if (this->optimization == NULL) 
07229                 this->optimization = new OptimizationOption();
07230         if (this->optimization->variables == NULL) 
07231                 this->optimization->variables = new VariableOption();
07232         if (this->optimization->variables->integerVariableBranchingWeights == NULL) 
07233                 this->optimization->variables->integerVariableBranchingWeights = new IntegerVariableBranchingWeights();
07234         return this->optimization->variables->integerVariableBranchingWeights->addVar(idx, value);
07235 }//setAnotherIntegerVariableBranchingWeight
07236 
07237 
07238 bool OSOption::setSOSVariableBranchingWeights(int numberOfSOS, SOSWeights** sos)
07239 {       if (this->optimization == NULL) 
07240                 this->optimization = new OptimizationOption();
07241         if (this->optimization->variables == NULL) 
07242                 this->optimization->variables = new VariableOption();
07243         if (this->optimization->variables->sosVariableBranchingWeights == NULL) 
07244                 this->optimization->variables->sosVariableBranchingWeights = new SOSVariableBranchingWeights();
07245         else
07246         {       int i;
07247                 for (i = 0; i < this->optimization->variables->sosVariableBranchingWeights->numberOfSOS; i++)
07248                         delete this->optimization->variables->sosVariableBranchingWeights->sos[i];
07249                 delete[] this->optimization->variables->sosVariableBranchingWeights->sos;
07250                 this->optimization->variables->sosVariableBranchingWeights->sos = NULL;
07251         }
07252         return this->optimization->variables->sosVariableBranchingWeights->setSOS(numberOfSOS, sos);
07253 }//setSOSVariableBranchingWeights
07254 
07255 bool OSOption::setAnotherSOSVariableBranchingWeight(int sosIdx, int nvar, double weight, int* idx, double* value)
07256 {       if (this->optimization == NULL) 
07257                 this->optimization = new OptimizationOption();
07258         if (this->optimization->variables == NULL) 
07259                 this->optimization->variables = new VariableOption();
07260         if (this->optimization->variables->sosVariableBranchingWeights == NULL) 
07261                 this->optimization->variables->sosVariableBranchingWeights = new SOSVariableBranchingWeights();
07262         return this->optimization->variables->sosVariableBranchingWeights->addSOS(sosIdx, nvar, weight, idx, value);
07263 }//setAnotherSOSVariableBranchingWeight
07264 
07265 bool OSOption::setNumberOfOtherVariableOptions(int numberOfOther)
07266 {
07267         if (optimization == NULL) return false;
07268         if (optimization->variables == NULL) 
07269                 optimization->variables = new VariableOption();
07270         if(optimization->variables->numberOfOtherVariableOptions < 0) return false;
07271 
07272         optimization->variables->numberOfOtherVariableOptions = numberOfOther;
07273         
07274         if (numberOfOther > 0)
07275         {
07276                 optimization->variables->other = new OtherVariableOption*[numberOfOther];
07277 
07278                 for (int j=0; j < numberOfOther; j++)
07279                         optimization->variables->other[j] = new OtherVariableOption();
07280         }
07281 
07282         return true;
07283 }//setNumberOfOtherVariableOptions
07284 
07285 bool OSOption::setOtherVariableOptionAttributes(int iOther, int numberOfVar,
07286                                 int numberOfEnumerations, std::string name,
07287                                 std::string value, std::string solver,
07288                                 std::string category, std::string type,
07289                                 std::string description)
07290 {
07291         if (optimization == NULL) return false;
07292         if (optimization->variables == NULL) return false;
07293         if (optimization->variables->other == NULL) return false;
07294 
07295         if (iOther < 0 || iOther >= optimization->variables->numberOfOtherVariableOptions) return false;
07296                 
07297         optimization->variables->other[iOther]->numberOfVar          = numberOfVar;
07298         optimization->variables->other[iOther]->numberOfEnumerations = numberOfEnumerations;
07299         optimization->variables->other[iOther]->name                 = name;
07300         optimization->variables->other[iOther]->value                = value;
07301         optimization->variables->other[iOther]->solver               = solver;
07302         optimization->variables->other[iOther]->category             = category;
07303         optimization->variables->other[iOther]->type                 = type;
07304         optimization->variables->other[iOther]->description          = description;
07305 
07306         if (numberOfVar > 0)
07307         {
07308                 optimization->variables->other[iOther]->var = new OtherVarOption*[numberOfVar];
07309                 for (int j=0; j<numberOfVar; j++) 
07310                         optimization->variables->other[iOther]->var[j] = new OtherVarOption();
07311         }
07312 
07313         if (numberOfEnumerations > 0)
07314         {
07315                 optimization->variables->other[iOther]->enumeration = new OtherOptionEnumeration*[numberOfEnumerations];
07316                 for (int j=0; j<numberOfEnumerations; j++) 
07317                         optimization->variables->other[iOther]->enumeration[j] = new OtherOptionEnumeration();
07318         }
07319         return true;
07320 }//setOtherVariableOptionAttributes
07321 
07322 bool OSOption::setOtherOptionEnumeration(int object, int otherOptionNumber, int enumerationNumber,
07323                         int numberOfEl, std::string value, std::string description, int* idxArray)
07324 {
07325         if (optimization == NULL) return false;
07326         if (numberOfEl < 0) return false;
07327 
07328         switch (object) 
07329         {
07330                 case ENUM_PROBLEM_COMPONENT_variables:
07331                 {
07332                         if (optimization->variables == NULL) return false;
07333                         if (optimization->variables->other == NULL) return false;
07334                         if (otherOptionNumber < 0 || otherOptionNumber >= optimization->variables->numberOfOtherVariableOptions) return false;
07335                         if (optimization->variables->other[otherOptionNumber] == NULL) return false;
07336                         for (int j=0; j<numberOfEl; j++) if (idxArray[j] < 0) return false;
07337 
07338                         if (optimization->variables->other[otherOptionNumber]->enumeration == NULL) return false;
07339                         if (enumerationNumber < 0 || enumerationNumber >= optimization->variables->other[otherOptionNumber]->numberOfEnumerations) return false;
07340                         if (optimization->variables->other[otherOptionNumber]->enumeration[enumerationNumber] == NULL) return false; 
07341 
07342                         return optimization->variables->other[otherOptionNumber]->enumeration[enumerationNumber]->setOtherOptionEnumeration(value, description, idxArray, numberOfEl);
07343                 }
07344 
07345                 case ENUM_PROBLEM_COMPONENT_objectives:
07346                 {
07347                         if (optimization->objectives == NULL) return false;
07348                         if (optimization->objectives->other == NULL) return false;
07349                         if (otherOptionNumber < 0 || otherOptionNumber >= optimization->objectives->numberOfOtherObjectiveOptions) return false;
07350                         if (optimization->objectives->other[otherOptionNumber] == NULL) return false;
07351                         for (int j=0; j<numberOfEl; j++) if (idxArray[j] >= 0) return false;
07352 
07353                         if (optimization->objectives->other[otherOptionNumber]->enumeration == NULL) return false;
07354                         if (enumerationNumber < 0 || enumerationNumber >= optimization->objectives->other[otherOptionNumber]->numberOfEnumerations) return false;
07355                         if (optimization->objectives->other[otherOptionNumber]->enumeration[enumerationNumber] == NULL) return false; 
07356 
07357                         return optimization->objectives->other[otherOptionNumber]->enumeration[enumerationNumber]->setOtherOptionEnumeration(value, description, idxArray, numberOfEl);
07358                 }
07359 
07360                 case ENUM_PROBLEM_COMPONENT_constraints:
07361                 {
07362                         if (optimization->constraints == NULL) return false;
07363                         if (optimization->constraints->other == NULL) return false;
07364                         if (otherOptionNumber < 0 || otherOptionNumber >= optimization->constraints->numberOfOtherConstraintOptions) return false;
07365                         if (optimization->constraints->other[otherOptionNumber] == NULL) return false;
07366                         for (int j=0; j<numberOfEl; j++) if (idxArray[j] < 0) return false;
07367 
07368                         if (optimization->constraints->other[otherOptionNumber]->enumeration == NULL) return false;
07369                         if (enumerationNumber < 0 || enumerationNumber >= optimization->constraints->other[otherOptionNumber]->numberOfEnumerations) return false;
07370                         if (optimization->constraints->other[otherOptionNumber]->enumeration[enumerationNumber] == NULL) return false; 
07371 
07372                         return optimization->constraints->other[otherOptionNumber]->enumeration[enumerationNumber]->setOtherOptionEnumeration(value, description, idxArray, numberOfEl);
07373                 }
07374                 default:
07375                         throw ErrorClass("target object not implemented in setOtherOptionEnumeration");
07376         }
07377 
07378 }//setOtherOptionEnumeration
07379 
07380 bool OSOption::setOtherVariableOptionVar(int otherOptionNumber, int varNumber,
07381                         int idx, std::string value, std::string lbValue, std::string ubValue)
07382 {
07383         if (optimization == NULL) return false;
07384 
07385         if (optimization->variables == NULL) return false;
07386         if (optimization->variables->other == NULL) return false;
07387         if (otherOptionNumber < 0 || otherOptionNumber >= optimization->variables->numberOfOtherVariableOptions) return false;
07388         if (optimization->variables->other[otherOptionNumber] == NULL) return false;
07389         if (idx < 0) return false;
07390 
07391         if (optimization->variables->other[otherOptionNumber]->var == NULL) return false;
07392         if (varNumber < 0 || varNumber >= optimization->variables->other[otherOptionNumber]->numberOfVar) return false;
07393         if (optimization->variables->other[otherOptionNumber]->var[varNumber] == NULL) return false; 
07394 
07395         optimization->variables->other[otherOptionNumber]->var[varNumber]->idx = idx;
07396         optimization->variables->other[otherOptionNumber]->var[varNumber]->value = value;
07397         optimization->variables->other[otherOptionNumber]->var[varNumber]->lbValue = lbValue;
07398         optimization->variables->other[otherOptionNumber]->var[varNumber]->ubValue = ubValue;
07399         return true;
07400 }//setOtherVariableOptionVar
07401 
07402 
07403 bool OSOption::setOtherVariableOptions(int numberOfOptions, OtherVariableOption** other)
07404 {       if (this->optimization == NULL)
07405                 this->optimization = new OptimizationOption();
07406         if (this->optimization->variables == NULL)
07407                 this->optimization->variables = new VariableOption();
07408         else
07409         {       int i;
07410                 for (i = 0; i < this->optimization->variables->numberOfOtherVariableOptions; i++)
07411                         delete this->optimization->variables->other[i];
07412                 delete[] this->optimization->variables->other;
07413                 this->optimization->variables->other = NULL;
07414         }
07415         return this->optimization->variables->setOther(numberOfOptions, other);
07416 }//setOtherVariableOptions
07417 
07418 bool OSOption::setAnOtherVariableOption(OtherVariableOption* optionValue)
07419 {       if (this->optimization == NULL)
07420                 this->optimization = new OptimizationOption();
07421         if (this->optimization->variables == NULL)
07422                 this->optimization->variables = new VariableOption();
07423         return this->optimization->variables->addOther(optionValue);
07424 }//setAnOtherVariableOption
07425 
07426 bool OSOption::setInitObjValues(int numberOfObj, int* idx, double* value)
07427 {
07428         if (this->optimization == NULL) 
07429                 this->optimization = new OptimizationOption();
07430         if (this->optimization->objectives == NULL) 
07431                 this->optimization->objectives = new ObjectiveOption();
07432         if (this->optimization->objectives->initialObjectiveValues != NULL) 
07433                 return false;
07434 
07435         this->optimization->objectives->initialObjectiveValues = new InitObjectiveValues();
07436 
07437         return this->optimization->objectives->initialObjectiveValues->setObj(numberOfObj, idx, value);
07438 }//setInitObjValues
07439 
07440 bool OSOption::setInitObjValuesSparse(int numberOfObj, InitObjValue** obj)
07441 {       if (this->optimization == NULL) 
07442                 this->optimization = new OptimizationOption();
07443         if (this->optimization->objectives == NULL) 
07444                 this->optimization->objectives = new ObjectiveOption();
07445         if (this->optimization->objectives->initialObjectiveValues == NULL) 
07446                 this->optimization->objectives->initialObjectiveValues = new InitObjectiveValues();
07447         else
07448         {       int i;
07449                 for (i = 0; i < this->optimization->objectives->initialObjectiveValues->numberOfObj; i++)
07450                         delete this->optimization->objectives->initialObjectiveValues->obj[i];
07451                 delete[] this->optimization->objectives->initialObjectiveValues->obj;
07452                 this->optimization->objectives->initialObjectiveValues->obj = NULL;
07453         }
07454         return this->optimization->objectives->initialObjectiveValues->setObj(numberOfObj, obj);
07455 }//setInitObjValuesSparse
07456 
07457 bool OSOption::setInitObjValuesDense(int numberOfObj, double *value)
07458 {       if (this->optimization == NULL) 
07459                 this->optimization = new OptimizationOption();
07460         if (this->optimization->objectives == NULL) 
07461                 this->optimization->objectives = new ObjectiveOption();
07462         if (this->optimization->objectives->initialObjectiveValues == NULL) 
07463                 this->optimization->objectives->initialObjectiveValues = new InitObjectiveValues();
07464         else
07465         {       delete[] this->optimization->objectives->initialObjectiveValues->obj;
07466                 this->optimization->objectives->initialObjectiveValues->obj = NULL;
07467         }
07468         int i;
07469         for (i = 0; i < numberOfObj; i++)
07470         {
07471 //              if (!CoinIsnan(value[i]))
07472                         if (!this->optimization->objectives->initialObjectiveValues->addObj(-1-i, value[i]))
07473                                 return false;
07474         }
07475         return true;
07476 }//setInitObjValuesDense
07477 
07478 bool OSOption::setAnotherInitObjValue(int idx, double value)
07479 {       if (this->optimization == NULL) 
07480                 this->optimization = new OptimizationOption();
07481         if (this->optimization->objectives == NULL) 
07482                 this->optimization->objectives = new ObjectiveOption();
07483         if (this->optimization->objectives->initialObjectiveValues == NULL) 
07484                 this->optimization->objectives->initialObjectiveValues = new InitObjectiveValues();
07485         return this->optimization->objectives->initialObjectiveValues->addObj(idx, value);
07486 }//setAnotherInitObjValue
07487 
07488 bool OSOption::setInitObjBounds(int numberOfObj, int* idx, double* lbValue, double* ubValue)
07489 {
07490         if (this->optimization == NULL) 
07491                 this->optimization = new OptimizationOption();
07492         if (this->optimization->objectives == NULL) 
07493                 this->optimization->objectives = new ObjectiveOption();
07494         if (this->optimization->objectives->initialObjectiveBounds != NULL) 
07495                 return false;
07496 
07497         this->optimization->objectives->initialObjectiveBounds = new InitObjectiveBounds();
07498 
07499         return this->optimization->objectives->initialObjectiveBounds->setObj(numberOfObj, idx, lbValue, ubValue);
07500 }//setInitObjBounds
07501 
07502 bool OSOption::setInitObjBoundsSparse(int numberOfObj, InitObjBound** obj)
07503 {       if (this->optimization == NULL) 
07504                 this->optimization = new OptimizationOption();
07505         if (this->optimization->objectives == NULL) 
07506                 this->optimization->objectives = new ObjectiveOption();
07507         if (this->optimization->objectives->initialObjectiveBounds == NULL) 
07508                 this->optimization->objectives->initialObjectiveBounds = new InitObjectiveBounds();
07509         else
07510         {       int i;
07511                 for (i = 0; i < this->optimization->objectives->initialObjectiveBounds->numberOfObj; i++)
07512                         delete this->optimization->objectives->initialObjectiveBounds->obj[i];
07513                 delete[] this->optimization->objectives->initialObjectiveBounds->obj;
07514                 this->optimization->objectives->initialObjectiveBounds->obj = NULL;
07515         }
07516         return this->optimization->objectives->initialObjectiveBounds->setObj(numberOfObj, obj);
07517 }//setInitObjBoundsSparse
07518 
07519 bool OSOption::setInitObjBoundsDense(int numberOfObj, double* lb, double* ub)
07520 {       if (this->optimization == NULL) 
07521                 this->optimization = new OptimizationOption();
07522         if (this->optimization->objectives == NULL) 
07523                 this->optimization->objectives = new ObjectiveOption();
07524         if (this->optimization->objectives->initialObjectiveBounds == NULL) 
07525                 this->optimization->objectives->initialObjectiveBounds = new InitObjectiveBounds();
07526         else
07527         {       delete[] this->optimization->objectives->initialObjectiveBounds->obj;
07528                 this->optimization->objectives->initialObjectiveBounds->obj = NULL;
07529         }
07530         int i;
07531         for (i = 0; i < numberOfObj; i++)
07532         {       if (!this->optimization->objectives->initialObjectiveBounds->addObj(-1-i, lb[i], ub[i]))
07533                         return false;
07534         }
07535         return true;
07536 }//setInitObjBoundsDense
07537 
07538 bool OSOption::setAnotherInitObjBound(int idx, double lb, double ub)
07539 {       if (this->optimization == NULL) 
07540                 this->optimization = new OptimizationOption();
07541         if (this->optimization->objectives == NULL) 
07542                 this->optimization->objectives = new ObjectiveOption();
07543         if (this->optimization->objectives->initialObjectiveBounds == NULL) 
07544                 this->optimization->objectives->initialObjectiveBounds = new InitObjectiveBounds();
07545         return this->optimization->objectives->initialObjectiveBounds->addObj(idx, lb, ub);
07546 }//setAnotherInitObjBound
07547 
07548 bool OSOption::setOtherObjectiveOptionObj(int otherOptionNumber, int objNumber,
07549                         int idx, std::string value, std::string lbValue, std::string ubValue)
07550 {
07551         if (optimization == NULL) return false;
07552 
07553         if (optimization->objectives == NULL) return false;
07554         if (optimization->objectives->other == NULL) return false;
07555         if (otherOptionNumber < 0 || otherOptionNumber >= optimization->objectives->numberOfOtherObjectiveOptions) return false;
07556         if (optimization->objectives->other[otherOptionNumber] == NULL) return false;
07557         if (idx >= 0) return false;
07558         
07559         if (optimization->objectives->other[otherOptionNumber]->obj == NULL) return false;
07560         if (objNumber < 0 || objNumber >= optimization->objectives->other[otherOptionNumber]->numberOfObj) return false;
07561         if (optimization->objectives->other[otherOptionNumber]->obj[objNumber] == NULL) return false; 
07562 
07563         optimization->objectives->other[otherOptionNumber]->obj[objNumber]->idx = idx;
07564         optimization->objectives->other[otherOptionNumber]->obj[objNumber]->value = value;
07565         optimization->objectives->other[otherOptionNumber]->obj[objNumber]->lbValue = lbValue;
07566         optimization->objectives->other[otherOptionNumber]->obj[objNumber]->ubValue = ubValue;
07567         return true;
07568 }//setOtherOptionObj
07569 
07570 bool OSOption::setNumberOfOtherObjectiveOptions(int numberOfOther)
07571 {
07572         if (optimization == NULL) return false;
07573         if (optimization->objectives == NULL) 
07574                 optimization->objectives = new ObjectiveOption();
07575         if (optimization->objectives->numberOfOtherObjectiveOptions < 0) return false;
07576 
07577         optimization->objectives->numberOfOtherObjectiveOptions = numberOfOther;
07578 
07579         if (numberOfOther > 0)
07580         {
07581                 optimization->objectives->other = new OtherObjectiveOption*[numberOfOther];
07582 
07583                 for (int j=0; j < numberOfOther; j++)
07584                         optimization->objectives->other[j] = new OtherObjectiveOption();
07585         }
07586         return true;
07587 
07588 }//setNumberOfOtherObjectiveOptions
07589 
07590 bool OSOption::setOtherObjectiveOptionAttributes(int iOther, int numberOfObj,
07591                                 int numberOfEnumerations, std::string name,
07592                                 std::string value, std::string solver,
07593                                 std::string category, std::string type,
07594                                 std::string description)
07595 {
07596         if (optimization == NULL) return false;
07597         if (optimization->objectives == NULL) return false;
07598         if (optimization->objectives->other == NULL) return false;
07599 
07600         if (iOther < 0 || iOther >= optimization->objectives->numberOfOtherObjectiveOptions) return false;
07601                 
07602         optimization->objectives->other[iOther]->numberOfObj          = numberOfObj;
07603         optimization->objectives->other[iOther]->numberOfEnumerations = numberOfEnumerations;
07604         optimization->objectives->other[iOther]->name                 = name;
07605         optimization->objectives->other[iOther]->value                = value;
07606         optimization->objectives->other[iOther]->solver               = solver;
07607         optimization->objectives->other[iOther]->category             = category;
07608         optimization->objectives->other[iOther]->type                 = type;
07609         optimization->objectives->other[iOther]->description          = description;
07610 
07611         if (numberOfObj > 0)
07612         {
07613                 optimization->objectives->other[iOther]->obj = new OtherObjOption*[numberOfObj];
07614                 for (int j=0; j<numberOfObj; j++) 
07615                         optimization->objectives->other[iOther]->obj[j] = new OtherObjOption();
07616         }
07617 
07618         if (numberOfEnumerations > 0)
07619         {
07620                 optimization->objectives->other[iOther]->enumeration = new OtherOptionEnumeration*[numberOfEnumerations];
07621                 for (int j=0; j<numberOfEnumerations; j++) 
07622                         optimization->objectives->other[iOther]->enumeration[j] = new OtherOptionEnumeration();
07623         }
07624         return true;
07625 }//setOtherObjOptionAttributes
07626 
07627 bool OSOption::setOtherObjectiveOptions(int numberOfOptions, OtherObjectiveOption** other)
07628 {       if (this->optimization == NULL)
07629                 this->optimization = new OptimizationOption();
07630         if (this->optimization->objectives == NULL)
07631                 this->optimization->objectives = new ObjectiveOption();
07632         else
07633         {       int i;
07634                 for (i = 0; i < this->optimization->objectives->numberOfOtherObjectiveOptions; i++)
07635                         delete this->optimization->objectives->other[i];
07636                 delete[] this->optimization->objectives->other;
07637                 this->optimization->objectives->other = NULL;
07638         }
07639         return this->optimization->objectives->setOther(numberOfOptions, other);
07640 }//setOtherObjectiveOptions
07641 
07642 bool OSOption::setAnOtherObjectiveOption(OtherObjectiveOption* optionValue)
07643 {       if (this->optimization == NULL)
07644                 this->optimization = new OptimizationOption();
07645         if (this->optimization->objectives == NULL)
07646                 this->optimization->objectives = new ObjectiveOption();
07647         return this->optimization->objectives->addOther(optionValue);
07648 }//setAnOtherVariableOption
07649 
07650 
07651 bool OSOption::setInitConValues(int numberOfCon, int* idx, double* value)
07652 {
07653         if (this->optimization == NULL) 
07654                 this->optimization = new OptimizationOption();
07655         if (this->optimization->constraints == NULL) 
07656                 this->optimization->constraints = new ConstraintOption();
07657         if (this->optimization->constraints->initialConstraintValues != NULL) 
07658                 return false;
07659 
07660         this->optimization->constraints->initialConstraintValues = new InitConstraintValues();
07661 
07662         return this->optimization->constraints->initialConstraintValues->setCon(numberOfCon, idx, value);
07663 }//setInitConValues
07664 
07665 
07666 bool OSOption::setInitConValuesSparse(int numberOfCon, InitConValue** con)
07667 {       if (this->optimization == NULL) 
07668                 this->optimization = new OptimizationOption();
07669         if (this->optimization->constraints == NULL) 
07670                 this->optimization->constraints = new ConstraintOption();
07671         if (this->optimization->constraints->initialConstraintValues == NULL) 
07672                 this->optimization->constraints->initialConstraintValues = new InitConstraintValues();
07673         else
07674         {       int i;
07675                 for (i = 0; i < this->optimization->constraints->initialConstraintValues->numberOfCon; i++)
07676                         delete this->optimization->constraints->initialConstraintValues->con[i];
07677                 delete[] this->optimization->constraints->initialConstraintValues->con;
07678                 this->optimization->constraints->initialConstraintValues->con = NULL;
07679         }
07680         return this->optimization->constraints->initialConstraintValues->setCon(numberOfCon, con);
07681 }//setInitConValuesSparse
07682 
07683 bool OSOption::setInitConValuesDense(int numberOfCon, double *value)
07684 {       if (this->optimization == NULL) 
07685                 this->optimization = new OptimizationOption();
07686         if (this->optimization->constraints == NULL) 
07687                 this->optimization->constraints = new ConstraintOption();
07688         if (this->optimization->constraints->initialConstraintValues == NULL) 
07689                 this->optimization->constraints->initialConstraintValues = new InitConstraintValues();
07690         else
07691         {       delete[] this->optimization->constraints->initialConstraintValues->con;
07692                 this->optimization->constraints->initialConstraintValues->con = NULL;
07693         }
07694         int i;
07695         for (i = 0; i < numberOfCon; i++)
07696         {
07697 //              if (!CoinIsnan(value[i]))
07698                         if (!this->optimization->constraints->initialConstraintValues->addCon(i, value[i]))
07699                                 return false;
07700         }
07701         return true;
07702 }//setInitConValuesDense
07703 
07704 bool OSOption::setAnotherInitConValue(int idx, double value)
07705 {       if (this->optimization == NULL) 
07706                 this->optimization = new OptimizationOption();
07707         if (this->optimization->constraints == NULL) 
07708                 this->optimization->constraints = new ConstraintOption();
07709         if (this->optimization->constraints->initialConstraintValues == NULL) 
07710                 this->optimization->constraints->initialConstraintValues = new InitConstraintValues();
07711         return this->optimization->constraints->initialConstraintValues->addCon(idx, value);
07712 }//setAnotherInitConValue
07713 
07714 bool OSOption::setInitDualValues(int numberOfCon, int* idx, double* lbValue, double* ubValue)
07715 {
07716         if (this->optimization == NULL) 
07717                 this->optimization = new OptimizationOption();
07718         if (this->optimization->constraints == NULL) 
07719                 this->optimization->constraints = new ConstraintOption();
07720         if (this->optimization->constraints->initialDualValues != NULL) 
07721                 return false;
07722 
07723         this->optimization->constraints->initialDualValues = new InitDualVariableValues();
07724 
07725         return this->optimization->constraints->initialDualValues->setCon(numberOfCon, idx, lbValue, ubValue);
07726 }//setInitDualValues
07727 
07728 
07729 bool OSOption::setInitDualVarValuesSparse(int numberOfCon, InitDualVarValue** con)
07730 {       if (this->optimization == NULL) 
07731                 this->optimization = new OptimizationOption();
07732         if (this->optimization->constraints == NULL) 
07733                 this->optimization->constraints = new ConstraintOption();
07734         if (this->optimization->constraints->initialDualValues == NULL) 
07735                 this->optimization->constraints->initialDualValues = new InitDualVariableValues();
07736         else
07737         {       int i;
07738                 for (i = 0; i < this->optimization->constraints->initialDualValues->numberOfCon; i++)
07739                         delete this->optimization->constraints->initialDualValues->con[i];
07740                 delete[] this->optimization->constraints->initialDualValues->con;
07741                 this->optimization->constraints->initialDualValues->con = NULL;
07742         }
07743         return this->optimization->constraints->initialDualValues->setCon(numberOfCon, con);
07744 }//setInitDualVarValuesSparse
07745 
07746 bool OSOption::setInitDualVarValuesDense(int numberOfCon, double* lb, double* ub)
07747 {       if (this->optimization == NULL) 
07748                 this->optimization = new OptimizationOption();
07749         if (this->optimization->constraints == NULL) 
07750                 this->optimization->constraints = new ConstraintOption();
07751         if (this->optimization->constraints->initialDualValues == NULL) 
07752                 this->optimization->constraints->initialDualValues = new InitDualVariableValues();
07753         else
07754         {       delete[] this->optimization->constraints->initialDualValues->con;
07755                 this->optimization->constraints->initialDualValues->con = NULL;
07756         }
07757         int i;
07758         for (i = 0; i < numberOfCon; i++)
07759         {       if ((lb[i] != 0.0) || (ub[i] != 0.0))
07760                         if (!this->optimization->constraints->initialDualValues->addCon(i, lb[i], ub[i]))
07761                                 return false;   
07762         }
07763         return true;
07764 }//setInitDualVarValuesDense
07765 
07766 bool OSOption::setAnotherInitDualVarValue(int idx, double lbValue, double ubValue)
07767 {       if (this->optimization == NULL) 
07768                 this->optimization = new OptimizationOption();
07769         if (this->optimization->constraints == NULL) 
07770                 this->optimization->constraints = new ConstraintOption();
07771         if (this->optimization->constraints->initialDualValues == NULL) 
07772                 this->optimization->constraints->initialDualValues = new InitDualVariableValues();
07773         return this->optimization->constraints->initialDualValues->addCon(idx, lbValue, ubValue);
07774 }//setAnotherInitConValue
07775 
07776 bool OSOption::setNumberOfOtherConstraintOptions(int numberOfOther)
07777 {
07778         if (optimization == NULL) return false;
07779         if (optimization->constraints == NULL)  
07780                 optimization->constraints = new ConstraintOption();
07781         if (optimization->constraints->numberOfOtherConstraintOptions < 0) return false;
07782 
07783         optimization->constraints->numberOfOtherConstraintOptions = numberOfOther;
07784 
07785         if (numberOfOther > 0)
07786         {
07787                 optimization->constraints->other = new OtherConstraintOption*[numberOfOther];
07788 
07789                 for (int j=0; j < numberOfOther; j++)
07790                         optimization->constraints->other[j] = new OtherConstraintOption();
07791         }
07792 
07793         return true;
07794 }//setNumberOfOtherConstraintOptions
07795 
07796 bool OSOption::setOtherConstraintOptionAttributes(int iOther, int numberOfCon,
07797                                 int numberOfEnumerations, std::string name,
07798                                 std::string value, std::string solver,
07799                                 std::string category, std::string type,
07800                                 std::string description)
07801 {
07802         if (optimization == NULL) return false;
07803         if (optimization->constraints == NULL) return false;
07804         if (optimization->constraints->other == NULL) return false;
07805         if (iOther < 0 || iOther >= optimization->constraints->numberOfOtherConstraintOptions) return false;
07806                 
07807         optimization->constraints->other[iOther]->numberOfCon          = numberOfCon;
07808         optimization->constraints->other[iOther]->numberOfEnumerations = numberOfEnumerations;
07809         optimization->constraints->other[iOther]->name                 = name;
07810         optimization->constraints->other[iOther]->value                = value;
07811         optimization->constraints->other[iOther]->solver               = solver;
07812         optimization->constraints->other[iOther]->category             = category;
07813         optimization->constraints->other[iOther]->type                 = type;
07814         optimization->constraints->other[iOther]->description          = description;
07815 
07816         if (numberOfCon > 0)
07817         {
07818                 optimization->constraints->other[iOther]->con = new OtherConOption*[numberOfCon];
07819                 for (int j=0; j<numberOfCon; j++) 
07820                         optimization->constraints->other[iOther]->con[j] = new OtherConOption();
07821         }
07822 
07823         if (numberOfEnumerations > 0)
07824         {
07825                 optimization->constraints->other[iOther]->enumeration = new OtherOptionEnumeration*[numberOfEnumerations];
07826                 for (int j=0; j<numberOfEnumerations; j++) 
07827                         optimization->constraints->other[iOther]->enumeration[j] = new OtherOptionEnumeration();
07828         }
07829         return true;
07830 }//setOtherConOptionAttributes
07831 
07832 
07833 bool OSOption::setOtherConstraintOptionCon(int otherOptionNumber, int conNumber,
07834                         int idx, std::string value, std::string lbValue, std::string ubValue)
07835 {
07836         if (optimization == NULL) return false;
07837 
07838         if (optimization->constraints == NULL) return false;
07839         if (optimization->constraints->other == NULL) return false;
07840         if (otherOptionNumber < 0 || otherOptionNumber >= optimization->constraints->numberOfOtherConstraintOptions) return false;
07841         if (optimization->constraints->other[otherOptionNumber] == NULL) return false;
07842         if (idx < 0) return false;
07843 
07844         if (optimization->constraints->other[otherOptionNumber]->con == NULL) return false;
07845         if (conNumber < 0 || conNumber >= optimization->constraints->other[otherOptionNumber]->numberOfCon) return false;
07846         if (optimization->constraints->other[otherOptionNumber]->con[conNumber] == NULL) return false; 
07847 
07848         optimization->constraints->other[otherOptionNumber]->con[conNumber]->idx = idx;
07849         optimization->constraints->other[otherOptionNumber]->con[conNumber]->value = value;
07850         optimization->constraints->other[otherOptionNumber]->con[conNumber]->lbValue = lbValue;
07851         optimization->constraints->other[otherOptionNumber]->con[conNumber]->ubValue = ubValue;
07852         return true;
07853 }//setOtherOptionCon
07854 
07855 
07856 
07857 bool OSOption::setOtherConstraintOptions(int numberOfOptions, OtherConstraintOption** other)
07858 {       if (this->optimization == NULL)
07859                 this->optimization = new OptimizationOption();
07860         if (this->optimization->constraints == NULL)
07861                 this->optimization->constraints = new ConstraintOption();
07862         else
07863         {       int i;
07864                 for (i = 0; i < this->optimization->constraints->numberOfOtherConstraintOptions; i++)
07865                         delete this->optimization->constraints->other[i];
07866                 delete[] this->optimization->constraints->other;
07867                 this->optimization->constraints->other = NULL;
07868         }
07869         return this->optimization->constraints->setOther(numberOfOptions, other);
07870 }//setOtherConstraintOptions
07871 
07872 bool OSOption::setAnOtherConstraintOption(OtherConstraintOption* optionValue)
07873 {       if (this->optimization == NULL)
07874                 this->optimization = new OptimizationOption();
07875         if (this->optimization->constraints == NULL)
07876                 this->optimization->constraints = new ConstraintOption();
07877         return this->optimization->constraints->addOther(optionValue);
07878 }//setAnOtherConstraintOption
07879 
07880 
07881 bool OSOption::setNumberOfSolverOptions(int numberOfOptions)
07882 {
07883         if (optimization == NULL) return false;
07884         if (optimization->solverOptions != NULL) return false;
07885 
07886         optimization->solverOptions = new SolverOptions();
07887         optimization->solverOptions->numberOfSolverOptions = numberOfOptions;
07888         optimization->solverOptions->solverOption = new SolverOption*[numberOfOptions];
07889 
07890         for (int j=0; j < numberOfOptions; j++)
07891                 optimization->solverOptions->solverOption[j] = new SolverOption();
07892         return true;
07893 }//setNumberOfSolverOptions
07894 
07895 bool OSOption::setSolverOptionContent(int iOption, int numberOfItems,
07896                                 std::string name,
07897                                 std::string value, std::string solver,
07898                                 std::string category, std::string type,
07899                                 std::string description, std::string *itemList)
07900 {
07901         if (optimization == NULL) return false;
07902         if (optimization->solverOptions == NULL) return false;
07903         if (optimization->solverOptions->solverOption == NULL) return false;
07904 
07905         if (iOption < 0 || iOption >= optimization->solverOptions->numberOfSolverOptions) return false;
07906                 
07907         optimization->solverOptions->solverOption[iOption]->numberOfItems = numberOfItems;
07908         optimization->solverOptions->solverOption[iOption]->name          = name;
07909         optimization->solverOptions->solverOption[iOption]->value         = value;
07910         optimization->solverOptions->solverOption[iOption]->solver        = solver;
07911         optimization->solverOptions->solverOption[iOption]->category      = category;
07912         optimization->solverOptions->solverOption[iOption]->type          = type;
07913         optimization->solverOptions->solverOption[iOption]->description   = description;
07914 
07915         if (numberOfItems > 0)
07916         {
07917                 optimization->solverOptions->solverOption[iOption]->item = new std::string[numberOfItems];
07918                 for (int j=0; j<numberOfItems; j++) 
07919                         optimization->solverOptions->solverOption[iOption]->item[j] = itemList[j];
07920         }
07921 
07922         return true;
07923 }//setSolverOptionContent
07924 
07925 bool OSOption::setSolverOptions(int numberOfSolverOptions, SolverOption** solverOption)
07926 {       if (this->optimization == NULL) 
07927                 this->optimization = new OptimizationOption();
07928         if (this->optimization->solverOptions == NULL) 
07929                 this->optimization->solverOptions = new SolverOptions();
07930         else
07931         {       int i;
07932                 for (i = 0; i < this->optimization->solverOptions->numberOfSolverOptions; i++)
07933                         delete this->optimization->solverOptions->solverOption[i];
07934                 delete[] this->optimization->solverOptions->solverOption;
07935                 this->optimization->solverOptions->solverOption = NULL;
07936         }
07937         return this->optimization->solverOptions->setSolverOptions(numberOfSolverOptions, solverOption);
07938 }//setSolverOptions
07939 
07940 bool OSOption::setAnotherSolverOption(std::string name, std::string value, std::string solver, 
07941                  std::string category, std::string type, std::string description)
07942 {       if (this->optimization == NULL) 
07943                 this->optimization = new OptimizationOption();
07944         if (this->optimization->solverOptions == NULL) 
07945                 this->optimization->solverOptions = new SolverOptions();
07946         return this->optimization->solverOptions->addSolverOption(name, value, solver, category, type, description);
07947 }//setAnotherSolverOption
07948 
07949 
07950 bool OSOption::setOptionStr(std::string optionName, std::string optionValue)
07951 {       if (optionName == "serviceURI") 
07952                 return this->setServiceURI(optionValue);
07953 
07954         if (optionName == "serviceName") 
07955                 return this->setServiceName(optionValue);
07956 
07957         if (optionName == "instanceName") 
07958                 return this->setInstanceName(optionValue);
07959 
07960         if (optionName == "instanceLocation") 
07961                 return this->setInstanceLocation(optionValue);
07962 
07963         if (optionName == "locationType") 
07964                 return this->setInstanceLocationType(optionValue);
07965 
07966         if (optionName == "jobID") 
07967                 return this->setJobID(optionValue);
07968 
07969         if (optionName == "solverName") 
07970                 return this->setSolverToInvoke(optionValue);
07971 
07972         if (optionName == "solverToInvoke") 
07973                 return this->setSolverToInvoke(optionValue);
07974 
07975         if (optionName == "license") 
07976                 return this->setLicense(optionValue);
07977 
07978         if (optionName == "userName") 
07979                 return this->setUserName(optionValue);
07980 
07981         if (optionName == "password") 
07982                 return this->setPassword(optionValue);
07983 
07984         if (optionName == "contact") 
07985                 return this->setContact(optionValue);
07986 
07987         if (optionName == "transportType") 
07988                 return this->setContactTransportType(optionValue);
07989 
07990         if (optionName == "minDiskSpaceUnit") 
07991                 return this->setMinDiskSpaceUnit(optionValue);
07992 
07993         if (optionName == "minMemoryUnit") 
07994                 return this->setMinMemoryUnit(optionValue);
07995 
07996         if (optionName == "minCPUSpeedUnit") 
07997                 return this->setMinCPUSpeedUnit(optionValue);
07998 
07999         if (optionName == "serviceType") 
08000                 return this->setServiceType(optionValue);
08001 
08002         if (optionName == "maxTimeUnit") 
08003                 return this->setMaxTimeUnit(optionValue);
08004 
08005         if (optionName == "requestedStartTime") 
08006                 return this->setRequestedStartTime(optionValue);
08007 
08008         return false;
08009 }//setOptionStr
08010 
08011 
08012 bool OSOption::setOptionInt(std::string optionName, int optionValue)
08013 {       if (optionName == "minCPUNumber")
08014                 return this->setMinCPUNumber(optionValue);
08015 
08016         return false;
08017 }//setOptionInt
08018 
08019 
08020 bool OSOption::setOptionDbl(std::string optionName, double value)
08021 {       if (optionName == "minDiskSpaceValue") 
08022                 return this->setMinDiskSpace(value);
08023 
08024         if (optionName == "minMemoryValue") 
08025                 return this->setMinMemorySize(value);
08026 
08027         if (optionName == "minCPUSpeedValue") 
08028                 return this->setMinCPUSpeed(value);
08029 
08030         if (optionName == "maxTime") 
08031                 return this->setMaxTime(value);
08032 
08033         return false;
08034 }//setOptionDbl
08035 
08036 /***************************************************
08037  * methods to test whether two OSOption objects 
08038  * or their components are equal to each other
08039  ***************************************************/
08040 bool OSOption::IsEqual(OSOption *that)
08041 {
08042         #ifdef DEBUG_OSOPTION
08043                 cout << "Start comparing in OSOption" << endl;
08044         #endif
08045         if (this == NULL)
08046         {       if (that == NULL)
08047                         return true;
08048                 else
08049                 {
08050                         #ifdef DEBUG_OSOPTION
08051                                 cout << "First object is NULL, second is not" << endl;
08052                         #endif
08053                         return false;
08054                 }
08055         }
08056         else 
08057         {       if (that == NULL)
08058                 {
08059                         #ifdef DEBUG_OSOPTION
08060                                 cout << "Second object is NULL, first is not" << endl;
08061                         #endif
08062                         return false;
08063                 }
08064                 else    
08065                 {
08066                         if (!this->optionHeader->IsEqual(that->optionHeader))
08067                                 return false;
08068                         if (!this->general->IsEqual(that->general))
08069                                 return false;
08070                         if (!this->system->IsEqual(that->system))
08071                                 return false;
08072                         if (!this->service->IsEqual(that->service))
08073                                 return false;
08074                         if (!this->job->IsEqual(that->job))
08075                                 return false;
08076                         if (!this->optimization->IsEqual(that->optimization))
08077                                 return false;
08078                         return true;
08079                 }
08080         }
08081 }//OSOption::IsEqual
08082 
08083 
08084 bool GeneralOption::IsEqual(GeneralOption *that)
08085 {       
08086 #ifdef DEBUG_OSOPTION
08087         cout << "Start comparing in GeneralOption" << endl;
08088 #endif
08089         if (this == NULL)
08090         {       if (that == NULL)
08091                         return true;
08092                 else
08093                 {
08094                         #ifdef DEBUG_OSOPTION
08095                                 cout << "First object is NULL, second is not" << endl;
08096                         #endif
08097                         return false;
08098                 }
08099         }
08100         else 
08101         {       if (that == NULL)
08102                 {
08103                         #ifdef DEBUG_OSOPTION
08104                                 cout << "Second object is NULL, first is not" << endl;
08105                         #endif
08106                         return false;
08107                 }
08108                 else    
08109                 {       bool same;
08110                         same =  (this->serviceURI     == that->serviceURI);
08111                         same = ((this->serviceName    == that->serviceName )   && same);
08112                         same = ((this->instanceName   == that->instanceName )  && same);
08113                         same = ((this->jobID          == that->jobID )         && same);
08114                         same = ((this->solverToInvoke == that->solverToInvoke) && same);
08115                         same = ((this->license        == that->license )       && same);
08116                         same = ((this->userName       == that->userName )      && same);
08117                         same = ((this->password       == that->password )      && same);
08118                         if (!same) 
08119                         {
08120                                 #ifdef DEBUG_OSOPTION
08121                                 cout << "serviceURI:    " << this->serviceURI     << " vs. " << that->serviceURI     << endl;
08122                                 cout << "serviceName:   " << this->serviceName    << " vs. " << that->serviceName    << endl;
08123                                 cout << "instanceName:  " << this->instanceName   << " vs. " << that->instanceName   << endl;
08124                                 cout << "jobID:         " << this->jobID          << " vs. " << that->jobID          << endl;
08125                                 cout << "solverToInvoke:" << this->solverToInvoke << " vs. " << that->solverToInvoke << endl;
08126                                 cout << "license:       " << this->license        << " vs. " << that->license        << endl;
08127                                 cout << "userName:      " << this->userName       << " vs. " << that->userName       << endl;
08128                                 cout << "password:      " << this->password       << " vs. " << that->password       << endl;
08129                                 #endif
08130                                 return false;
08131                         }
08132                         if (!this->instanceLocation->IsEqual(that->instanceLocation))
08133                                 return false;
08134                         if (!this->contact->IsEqual(that->contact))
08135                                 return false;
08136                         if (!this->otherOptions->IsEqual(that->otherOptions))
08137                                 return false;
08138                         return true;
08139                 }
08140         }
08141 }//GeneralOption::IsEqual
08142 
08143 
08144 bool SystemOption::IsEqual(SystemOption *that)
08145 {       
08146 #ifdef DEBUG_OSOPTION
08147         cout << "Start comparing in SystemOption" << endl;
08148 #endif
08149         if (this == NULL)
08150         {       if (that == NULL)
08151                         return true;
08152                 else
08153                 {
08154                         #ifdef DEBUG_OSOPTION
08155                                 cout << "First object is NULL, second is not" << endl;
08156                         #endif
08157                         return false;
08158                 }
08159         }
08160         else 
08161         {       if (that == NULL)
08162                 {
08163                         #ifdef DEBUG_OSOPTION
08164                                 cout << "Second object is NULL, first is not" << endl;
08165                         #endif
08166                         return false;
08167                 }
08168                 else    
08169                 {
08170                         if (!this->minDiskSpace->IsEqual(that->minDiskSpace))
08171                                 return false;
08172                         if (!this->minMemorySize->IsEqual(that->minMemorySize))
08173                                 return false;
08174                         if (!this->minCPUSpeed->IsEqual(that->minCPUSpeed))
08175                                 return false;
08176                         if (!this->minCPUNumber->IsEqual(that->minCPUNumber))
08177                                 return false;
08178                         if (!this->otherOptions->IsEqual(that->otherOptions))
08179                                 return false;
08180                         return true;
08181                 }       
08182         }
08183 }//SystemOption::IsEqual
08184 
08185 
08186 bool ServiceOption::IsEqual(ServiceOption *that)
08187 {       
08188 #ifdef DEBUG_OSOPTION
08189         cout << "Start comparing in ServiceOption" << endl;
08190 #endif
08191         if (this == NULL)
08192         {       if (that == NULL)
08193                         return true;
08194                 else
08195                 {
08196                         #ifdef DEBUG_OSOPTION
08197                                 cout << "First object is NULL, second is not" << endl;
08198                         #endif
08199                         return false;
08200                 }
08201         }
08202         else 
08203         {       if (that == NULL)
08204                 {
08205                         #ifdef DEBUG_OSOPTION
08206                                 cout << "Second object is NULL, first is not" << endl;
08207                         #endif
08208                         return false;
08209                 }
08210                 else
08211                 {       if (this->type != that->type)
08212                         {
08213                                 #ifdef DEBUG_OSOPTION
08214                                 cout << "service type: " << this->type << " vs. " << that->type << endl;
08215                                 #endif
08216                                 return false;
08217                         }
08218 
08219                         if (!this->otherOptions->IsEqual(that->otherOptions))
08220                                 return false;
08221                         return true;
08222                 }
08223         }
08224 }//ServiceOption::IsEqual
08225 
08226 
08227 bool JobOption::IsEqual(JobOption *that)
08228 {
08229 #ifdef DEBUG_OSOPTION
08230         cout << "Start comparing in JobOption" << endl;
08231 #endif
08232         if (this == NULL)
08233         {       if (that == NULL)
08234                         return true;
08235                 else
08236                 {
08237                         #ifdef DEBUG_OSOPTION
08238                                 cout << "First object is NULL, second is not" << endl;
08239                         #endif
08240                         return false;
08241                 }
08242         }
08243         else 
08244         {       if (that == NULL)
08245                 {
08246                         #ifdef DEBUG_OSOPTION
08247                                 cout << "Second object is NULL, first is not" << endl;
08248                         #endif
08249                         return false;
08250                 }
08251                 else    
08252                 {       if (this->requestedStartTime != that->requestedStartTime)
08253                         {
08254                                 #ifdef DEBUG_OSOPTION
08255                                 cout << "requestedStartTime: " << this->requestedStartTime << " vs. " << that->requestedStartTime << endl;
08256                                 #endif
08257                                 return false;
08258                         }
08259 
08260                         if (!this->maxTime->IsEqual(that->maxTime))
08261                                 return false;
08262                         if (!this->dependencies->IsEqual(that->dependencies))
08263                                 return false;
08264                         if (!this->requiredDirectories->IsEqual(that->requiredDirectories))
08265                                 return false;
08266                         if (!this->requiredFiles->IsEqual(that->requiredFiles))
08267                                 return false;
08268                         if (!this->directoriesToMake->IsEqual(that->directoriesToMake))
08269                                 return false;
08270                         if (!this->filesToMake->IsEqual(that->filesToMake))
08271                                 return false;
08272                         if (!this->inputDirectoriesToMove->IsEqual(that->inputDirectoriesToMove))
08273                                 return false;
08274                         if (!this->inputFilesToMove->IsEqual(that->inputFilesToMove))
08275                                 return false;
08276                         if (!this->outputFilesToMove->IsEqual(that->outputFilesToMove))
08277                                 return false;
08278                         if (!this->outputDirectoriesToMove->IsEqual(that->outputDirectoriesToMove))
08279                                 return false;
08280                         if (!this->filesToDelete->IsEqual(that->filesToDelete))
08281                                 return false;
08282                         if (!this->directoriesToDelete->IsEqual(that->directoriesToDelete))
08283                                 return false;
08284                         if (!this->processesToKill->IsEqual(that->processesToKill))
08285                                 return false;
08286                         if (!this->otherOptions->IsEqual(that->otherOptions))
08287                                 return false;
08288                         return true;
08289                 }
08290         }
08291 }//JobOption::IsEqual
08292 
08293 bool OptimizationOption::IsEqual(OptimizationOption *that)
08294 {
08295 #ifdef DEBUG_OSOPTION
08296         cout << "Start comparing in OptimizationOption" << endl;
08297 #endif
08298         if (this == NULL)
08299         {       if (that == NULL)
08300                         return true;
08301                 else
08302                 {
08303                         #ifdef DEBUG_OSOPTION
08304                                 cout << "First object is NULL, second is not" << endl;
08305                         #endif
08306                         return false;
08307                 }
08308         }
08309         else 
08310         {       if (that == NULL)
08311                 {
08312                         #ifdef DEBUG_OSOPTION
08313                                 cout << "Second object is NULL, first is not" << endl;
08314                         #endif
08315                         return false;
08316                 }
08317                 else    
08318                 {       if ((this->numberOfVariables != that->numberOfVariables) && 
08319                                 (this->numberOfVariables *  that->numberOfVariables) != 0)
08320                         {
08321                                 #ifdef DEBUG_OSOPTION
08322                                 cout << "numberOfVariables: " 
08323                                          << this->numberOfVariables << " vs. " << that->numberOfVariables << endl;
08324                                 #endif
08325                                 return false;
08326                         }
08327                         if ((this->numberOfObjectives != that->numberOfObjectives) && 
08328                                 (this->numberOfObjectives *  that->numberOfObjectives) != 0)
08329                         {
08330                                 #ifdef DEBUG_OSOPTION
08331                                 cout << "numberOfObjectives: " 
08332                                          << this->numberOfObjectives << " vs. " << that->numberOfObjectives << endl;
08333                                 #endif
08334                                 return false;
08335                         }
08336                         if ((this->numberOfConstraints != that->numberOfConstraints) && 
08337                                 (this->numberOfConstraints *  that->numberOfConstraints) != 0)
08338                         {
08339                                 #ifdef DEBUG_OSOPTION
08340                                 cout << "numberOfConstraints: " 
08341                                          << this->numberOfConstraints << " vs. " << that->numberOfConstraints << endl;
08342                                 #endif
08343                                 return false;
08344                         }
08345 
08346                         if (!this->variables->IsEqual(that->variables))
08347                                 return false;
08348                         if (!this->objectives->IsEqual(that->objectives))
08349                                 return false;
08350                         if (!this->constraints->IsEqual(that->constraints))
08351                                 return false;
08352                         if (!this->solverOptions->IsEqual(that->solverOptions))
08353                                 return false;
08354                         return true;
08355                 }
08356         }
08357 }//OptimizationOption::IsEqual
08358 
08359 bool InstanceLocationOption::IsEqual(InstanceLocationOption *that)
08360 {
08361 #ifdef DEBUG_OSOPTION
08362         cout << "Start comparing in InstanceLocationOption" << endl;
08363 #endif
08364         if (this == NULL)
08365         {       if (that == NULL)
08366                         return true;
08367                 else
08368                 {
08369                         #ifdef DEBUG_OSOPTION
08370                                 cout << "First object is NULL, second is not" << endl;
08371                         #endif
08372                         return false;
08373                 }
08374         }
08375         else 
08376         {       if (that == NULL)
08377                 {
08378                         #ifdef DEBUG_OSOPTION
08379                                 cout << "Second object is NULL, first is not" << endl;
08380                         #endif
08381                         return false;
08382                 }
08383                 else    
08384                 {       if ((this->locationType != that->locationType) || (this->value != that->value)) 
08385                         {       
08386                                 #ifdef DEBUG_OSOPTION
08387                                 cout << "location type: " << this->locationType << " vs. " << that->locationType << endl;
08388                                 cout << "value: "         << this->value        << " vs. " << that->value        << endl;
08389                                 #endif
08390                                 return false;
08391                         }
08392                         return true;
08393                 }
08394         }
08395 }//InstanceLocationOption::IsEqual
08396 
08397 bool ContactOption::IsEqual(ContactOption *that)
08398 {
08399 #ifdef DEBUG_OSOPTION
08400         cout << "Start comparing in ContactOption" << endl;
08401 #endif
08402         if (this == NULL)
08403         {       if (that == NULL)
08404                         return true;
08405                 else
08406                 {
08407                         #ifdef DEBUG_OSOPTION
08408                                 cout << "First object is NULL, second is not" << endl;
08409                         #endif
08410                         return false;
08411                 }
08412         }
08413         else 
08414         {       if (that == NULL)
08415                 {
08416                         #ifdef DEBUG_OSOPTION
08417                                 cout << "Second object is NULL, first is not" << endl;
08418                         #endif
08419                         return false;
08420                 }
08421                 else    
08422                 {       if ((this->transportType != that->transportType) || (this->value != that->value)) 
08423                         {       
08424                                 #ifdef DEBUG_OSOPTION
08425                                 cout << "transport type: " << this->transportType << " vs. " << that->transportType << endl;
08426                                 cout << "value: "          << this->value         << " vs. " << that->value         << endl;
08427                                 #endif
08428                                 return false;
08429                         }
08430                         return true;
08431                 }
08432         }
08433 }//ContactOption::IsEqual
08434 
08435 bool OtherOptions::IsEqual(OtherOptions *that)
08436 {
08437 #ifdef DEBUG_OSOPTION
08438         cout << "Start comparing in OtherOptions" << endl;
08439 #endif
08440         if (this == NULL)
08441         {       if (that == NULL)
08442                         return true;
08443                 else
08444                 {
08445                         #ifdef DEBUG_OSOPTION
08446                                 cout << "First object is NULL, second is not" << endl;
08447                         #endif
08448                         return false;
08449                 }
08450         }
08451         else 
08452         {       if (that == NULL)
08453                 {
08454                         #ifdef DEBUG_OSOPTION
08455                                 cout << "Second object is NULL, first is not" << endl;
08456                         #endif
08457                         return false;
08458                 }
08459                 else    
08460                 {       if (this->numberOfOtherOptions  != that->numberOfOtherOptions) 
08461                         {
08462                                 #ifdef DEBUG_OSOPTION
08463                                 cout << "numberOfOtherOptions: " << this->numberOfOtherOptions << " vs. " << that->numberOfOtherOptions << endl;
08464                                 #endif
08465                                 return false;
08466                         }
08467                         int i;
08468                         for (i = 0; i < this->numberOfOtherOptions; i++)
08469                                 if (!this->other[i]->IsEqual(that->other[i]))
08470                                         return false;
08471                         return true;
08472                 }
08473         }
08474 }//OtherOptions::IsEqual
08475 
08476 
08477 bool OtherOption::IsEqual(OtherOption *that)
08478 {
08479 #ifdef DEBUG_OSOPTION
08480         cout << "Start comparing in OtherOption" << endl;
08481 #endif
08482         if (this == NULL)
08483         {       if (that == NULL)
08484                         return true;
08485                 else
08486                 {
08487                         #ifdef DEBUG_OSOPTION
08488                                 cout << "First object is NULL, second is not" << endl;
08489                         #endif
08490                         return false;
08491                 }
08492         }
08493         else 
08494         {       if (that == NULL)
08495                 {
08496                         #ifdef DEBUG_OSOPTION
08497                                 cout << "Second object is NULL, first is not" << endl;
08498                         #endif
08499                         return false;
08500                 }
08501                 else    
08502                 {       if ((this->name  != that->name)  || 
08503                                 (this->value != that->value) || 
08504                                 (this->description != that->description) ) 
08505                         {
08506                                 #ifdef DEBUG_OSOPTION
08507                                 cout << "name: "        << this->name        << " vs. " << that->name        << endl;
08508                                 cout << "value: "       << this->value       << " vs. " << that->value       << endl;
08509                                 cout << "description: " << this->description << " vs. " << that->description << endl;
08510                                 #endif
08511                                 return false;
08512                         }
08513                         return true;
08514                 }
08515         }
08516 }//OtherOption::IsEqual
08517 
08518 bool MinDiskSpace::IsEqual(MinDiskSpace *that)
08519 {
08520 #ifdef DEBUG_OSOPTION
08521         cout << "Start comparing in MinDiskSpace" << endl;
08522 #endif
08523         if (this == NULL)
08524         {       if (that == NULL)
08525                         return true;
08526                 else
08527                 {
08528                         #ifdef DEBUG_OSOPTION
08529                                 cout << "First object is NULL, second is not" << endl;
08530                         #endif
08531                         return false;
08532                 }
08533         }
08534         else 
08535         {       if (that == NULL)
08536                 {
08537                         #ifdef DEBUG_OSOPTION
08538                                 cout << "Second object is NULL, first is not" << endl;
08539                         #endif
08540                         return false;
08541                 }
08542                 else    
08543                 {       if ((this->unit        != that->unit)  || 
08544                                 !isEqual(this->value, that->value) ||
08545                                 (this->description != that->description) ) 
08546                         {       
08547 #ifdef DEBUG_OSOPTION
08548                                 cout << "unit:        " << this->unit        << " vs. " << that->unit        << endl;
08549                                 cout << "value:       " << this->value       << " vs. " << that->value       << endl;
08550                                 cout << "description: " << this->description << " vs. " << that->description << endl;
08551 #endif  
08552                                 return false;
08553                         }
08554                         return true;
08555                 }
08556         }
08557 }//MinDiskSpace::IsEqual
08558 
08559 bool MinMemorySize::IsEqual(MinMemorySize *that)
08560 {
08561 #ifdef DEBUG_OSOPTION
08562         cout << "Start comparing in MinMemorySize" << endl;
08563 #endif
08564         if (this == NULL)
08565         {       if (that == NULL)
08566                         return true;
08567                 else
08568                 {
08569                         #ifdef DEBUG_OSOPTION
08570                                 cout << "First object is NULL, second is not" << endl;
08571                         #endif
08572                         return false;
08573                 }
08574         }
08575         else 
08576         {       if (that == NULL)
08577                 {
08578                         #ifdef DEBUG_OSOPTION
08579                                 cout << "Second object is NULL, first is not" << endl;
08580                         #endif
08581                         return false;
08582                 }
08583                 else    
08584                 {       if ((this->unit        != that->unit)  || 
08585 //                              (this->value       != that->value) ||
08586                                 !isEqual(this->value, that->value) ||
08587                                 (this->description != that->description) ) 
08588                         {
08589 #ifdef DEBUG_OSOPTION
08590                                 cout << "unit: "  << this->unit  << " vs. " << that->unit  << endl;
08591                                 cout << "value: " << this->value << " vs. " << that->value << endl;
08592 #endif  
08593                                 return false;
08594                         }
08595                         return true;
08596                 }
08597         }
08598 }//MinMemorySize::IsEqual
08599 
08600 bool MinCPUSpeed::IsEqual(MinCPUSpeed *that)
08601 {
08602 #ifdef DEBUG_OSOPTION
08603         cout << "Start comparing in MinCPUSpeed" << endl;
08604 #endif
08605         if (this == NULL)
08606         {       if (that == NULL)
08607                         return true;
08608                 else
08609                 {
08610                         #ifdef DEBUG_OSOPTION
08611                                 cout << "First object is NULL, second is not" << endl;
08612                         #endif
08613                         return false;
08614                 }
08615         }
08616         else 
08617         {       if (that == NULL)
08618                 {
08619                         #ifdef DEBUG_OSOPTION
08620                                 cout << "Second object is NULL, first is not" << endl;
08621                         #endif
08622                         return false;
08623                 }
08624                 else    
08625                 {       if ((this->unit        != that->unit)  || 
08626 //                              (this->value       != that->value) ||
08627                                 !isEqual(this->value, that->value) ||
08628                                 (this->description != that->description) ) 
08629                         {
08630 #ifdef DEBUG_OSOPTION
08631                                 cout << "unit: "  << this->unit  << " vs. " << that->unit  << endl;
08632                                 cout << "value: " << this->value << " vs. " << that->value << endl;
08633 #endif  
08634                                 return false;
08635                         }
08636                         return true;
08637                 }
08638         }
08639 }//MinCPUSpeed::IsEqual
08640 
08641 bool MinCPUNumber::IsEqual(MinCPUNumber *that)
08642 {
08643 #ifdef DEBUG_OSOPTION
08644         cout << "Start comparing in MinCPUNumber" << endl;
08645 #endif
08646         if (this == NULL)
08647         {       if (that == NULL)
08648                         return true;
08649                 else
08650                 {
08651                         #ifdef DEBUG_OSOPTION
08652                                 cout << "First object is NULL, second is not" << endl;
08653                         #endif
08654                         return false;
08655                 }
08656         }
08657         else 
08658         {       if (that == NULL)
08659                 {
08660                         #ifdef DEBUG_OSOPTION
08661                                 cout << "Second object is NULL, first is not" << endl;
08662                         #endif
08663                         return false;
08664                 }
08665                 else    
08666                 {       if ((this->description != that->description)  || 
08667                                 (this->value != that->value) )
08668                         {
08669 #ifdef DEBUG_OSOPTION
08670                                 cout << "description: " << this->description  << " vs. " << that->description  << endl;
08671                                 cout << "value:       " << this->value << " vs. " << that->value << endl;
08672 #endif  
08673                                 return false;
08674                         }
08675                         return true;
08676                 }
08677         }
08678 }//MinCPUNumber::IsEqual
08679 
08680 bool JobDependencies::IsEqual(JobDependencies *that)
08681 {
08682 #ifdef DEBUG_OSOPTION
08683         cout << "Start comparing in JobDependencies" << endl;
08684 #endif
08685         if (this == NULL)
08686         {       if (that == NULL)
08687                         return true;
08688                 else
08689                 {
08690                         #ifdef DEBUG_OSOPTION
08691                                 cout << "First object is NULL, second is not" << endl;
08692                         #endif
08693                         return false;
08694                 }
08695         }
08696         else 
08697         {       if (that == NULL)
08698                 {
08699                         #ifdef DEBUG_OSOPTION
08700                                 cout << "Second object is NULL, first is not" << endl;
08701                         #endif
08702                         return false;
08703                 }
08704                 else    
08705                 {       if (this->numberOfJobIDs != that->numberOfJobIDs)  
08706                         {
08707 #ifdef DEBUG_OSOPTION
08708                                 cout << "numberOfJobIDs: " << this->numberOfJobIDs << " vs. " << that->numberOfJobIDs << endl;
08709 #endif  
08710                                 return false;
08711                         }
08712                         int i;
08713                         for (i = 0; i < numberOfJobIDs; i++)
08714                                 if (this->jobID[i] != that->jobID[i])
08715                                 {
08716 #ifdef DEBUG_OSOPTION
08717                                         cout << "jobID[" << i << "]: " << this->jobID[i] << " vs. " << that->jobID[i] << endl;
08718 #endif  
08719                                         return false;
08720                                 }
08721                         return true;
08722                 }
08723         }
08724 }//JobDependencies::IsEqual
08725 
08726 bool DirectoriesAndFiles::IsEqual(DirectoriesAndFiles *that)
08727 {
08728 #ifdef DEBUG_OSOPTION
08729         cout << "Start comparing in DirectoriesAndFiles" << endl;
08730 #endif
08731         if (this == NULL)
08732         {       if (that == NULL)
08733                         return true;
08734                 else
08735                 {
08736                         #ifdef DEBUG_OSOPTION
08737                                 cout << "First object is NULL, second is not" << endl;
08738                         #endif
08739                         return false;
08740                 }
08741         }
08742         else 
08743         {       if (that == NULL)
08744                 {
08745                         #ifdef DEBUG_OSOPTION
08746                                 cout << "Second object is NULL, first is not" << endl;
08747                         #endif
08748                         return false;
08749                 }
08750                 else    
08751                 {       if (this->numberOfPaths != that->numberOfPaths)  
08752                         {
08753 #ifdef DEBUG_OSOPTION
08754                                 cout << "numberOfPaths: " << this->numberOfPaths << " vs. " << that->numberOfPaths << endl;
08755 #endif  
08756                                 return false;
08757                         }
08758                         int i;
08759                         for (i = 0; i < numberOfPaths; i++)
08760                                 if (this->path[i] != that->path[i])
08761                                 {
08762 #ifdef DEBUG_OSOPTION
08763                                         cout << "path[" << i << "]: \'" << this->path[i] << "\' vs. \'" << that->path[i] << "\'" << endl;
08764 #endif  
08765                                         return false;
08766                                 }
08767                         return true;
08768                 }
08769         }
08770 }//DirectoriesAndFiles::IsEqual
08771 
08772 bool PathPairs::IsEqual(PathPairs *that)
08773 {
08774 #ifdef DEBUG_OSOPTION
08775         cout << "Start comparing in PathPairs" << endl;
08776 #endif
08777         if (this == NULL)
08778         {       if (that == NULL)
08779                         return true;
08780                 else
08781                 {
08782                         #ifdef DEBUG_OSOPTION
08783                                 cout << "First object is NULL, second is not" << endl;
08784                         #endif
08785                         return false;
08786                 }
08787         }
08788         else 
08789         {       if (that == NULL)
08790                 {
08791                         #ifdef DEBUG_OSOPTION
08792                                 cout << "Second object is NULL, first is not" << endl;
08793                         #endif
08794                         return false;
08795                 }
08796                 else    
08797                 {       if (this->numberOfPathPairs != that->numberOfPathPairs)  
08798                         {
08799 #ifdef DEBUG_OSOPTION
08800                                 cout << "numberOfPathPairs: " << this->numberOfPathPairs << " vs. " << that->numberOfPathPairs << endl;
08801 #endif  
08802                                 return false;
08803                         }
08804                         int i;
08805                         for (i = 0; i < numberOfPathPairs; i++)
08806                                 if (!this->pathPair[i]->IsEqual(that->pathPair[i]))
08807                                         return false;
08808                         return true;
08809                 }
08810         }
08811 }//PathPairs::IsEqual
08812 
08813         
08814 bool PathPair::IsEqual(PathPair *that)
08815 {
08816 #ifdef DEBUG_OSOPTION
08817         cout << "Start comparing in PathPair" << endl;
08818 #endif
08819         if (this == NULL)
08820         {       if (that == NULL)
08821                         return true;
08822                 else
08823                 {
08824                         #ifdef DEBUG_OSOPTION
08825                                 cout << "First object is NULL, second is not" << endl;
08826                         #endif
08827                         return false;
08828                 }
08829         }
08830         else 
08831         {       if (that == NULL)
08832                 {
08833                         #ifdef DEBUG_OSOPTION
08834                                 cout << "Second object is NULL, first is not" << endl;
08835                         #endif
08836                         return false;
08837                 }
08838                 else    
08839                 {       if ((this->from != that->from) || (this->to != that->to) || 
08840                                 (this->makeCopy != that->makeCopy))  
08841                         {
08842 #ifdef DEBUG_OSOPTION
08843                                 cout << "from: "     << this->from     << " vs. " << that->from     << endl;
08844                                 cout << "to: "       << this->to       << " vs. " << that->to       << endl;
08845                                 cout << "makeCopy: " << this->makeCopy << " vs. " << that->makeCopy << endl;
08846 #endif  
08847                                 return false;
08848                         }
08849                         return true;
08850                 }
08851         }
08852 }//PathPair::IsEqual
08853 
08854 bool Processes::IsEqual(Processes *that)
08855 {
08856 #ifdef DEBUG_OSOPTION
08857         cout << "Start comparing in Processes" << endl;
08858 #endif
08859         if (this == NULL)
08860         {       if (that == NULL)
08861                         return true;
08862                 else
08863                 {
08864                         #ifdef DEBUG_OSOPTION
08865                                 cout << "First object is NULL, second is not" << endl;
08866                         #endif
08867                         return false;
08868                 }
08869         }
08870         else 
08871         {       if (that == NULL)
08872                 {
08873                         #ifdef DEBUG_OSOPTION
08874                                 cout << "Second object is NULL, first is not" << endl;
08875                         #endif
08876                         return false;
08877                 }
08878                 else    
08879                 {       if (this->numberOfProcesses != that->numberOfProcesses)  
08880                         {
08881 #ifdef DEBUG_OSOPTION
08882                                 cout << "numberOfProcesses: " << this->numberOfProcesses << " vs. " << that->numberOfProcesses << endl;
08883 #endif  
08884                                 return false;
08885                         }
08886                         int i;
08887                         for (i = 0; i < numberOfProcesses; i++)
08888                                 if (this->process[i] != that->process[i])
08889                                 {
08890 #ifdef DEBUG_OSOPTION
08891                                         cout << "process[" << i << "]: " << this->process[i] << " vs. " << that->process[i] << endl;
08892 #endif  
08893                                         return false;
08894                                 }
08895                         return true;
08896                 }
08897         }
08898 }//Processes::IsEqual
08899 
08900 
08901 bool VariableOption::IsEqual(VariableOption *that)
08902 {
08903 #ifdef DEBUG_OSOPTION
08904         cout << "Start comparing in VariableOption" << endl;
08905 #endif
08906         if (this == NULL)
08907         {       if (that == NULL)
08908                         return true;
08909                 else
08910                 {
08911                         #ifdef DEBUG_OSOPTION
08912                                 cout << "First object is NULL, second is not" << endl;
08913                         #endif
08914                         return false;
08915                 }
08916         }
08917         else 
08918         {       if (that == NULL)
08919                 {
08920                         #ifdef DEBUG_OSOPTION
08921                                 cout << "Second object is NULL, first is not" << endl;
08922                         #endif
08923                         return false;
08924                 }
08925                 else    
08926                 {       
08927                         if (!this->initialVariableValues->IsEqual(that->initialVariableValues))
08928                                 return false;
08929                         if (!this->initialVariableValuesString->IsEqual(that->initialVariableValuesString))
08930                                 return false;
08931                         if (!this->initialBasisStatus->IsEqual(that->initialBasisStatus))
08932                                 return false;
08933                         if (!this->integerVariableBranchingWeights->IsEqual(that->integerVariableBranchingWeights))
08934                                 return false;
08935                         if (!this->sosVariableBranchingWeights->IsEqual(that->sosVariableBranchingWeights))
08936                                 return false;
08937 
08938                         if (this->numberOfOtherVariableOptions != that->numberOfOtherVariableOptions)  
08939                         {
08940 #ifdef DEBUG_OSOPTION
08941                                 cout << "numberOfOtherVariableOptions: " << this->numberOfOtherVariableOptions << " vs. " << that->numberOfOtherVariableOptions << endl;
08942 #endif  
08943                                 return false;
08944                         }
08945 
08946                         int i;
08947                         for (i = 0; i < numberOfOtherVariableOptions; i++)
08948                                 if (!this->other[i]->IsEqual(that->other[i]))
08949                                 {
08950 #ifdef DEBUG_OSOPTION
08951                                         cout << "other[" << i << "]: " << this->other[i] << " vs. " << that->other[i] << endl;
08952 #endif  
08953                                         return false;
08954                                 }
08955 
08956                         return true;
08957                 }
08958         }
08959 }//VariableOption::IsEqual
08960 
08961 bool InitVariableValues::IsEqual(InitVariableValues *that)
08962 {
08963 #ifdef DEBUG_OSOPTION
08964         cout << "Start comparing in InitVariableValues" << endl;
08965 #endif
08966         if (this == NULL)
08967         {       if (that == NULL)
08968                         return true;
08969                 else
08970                 {
08971                         #ifdef DEBUG_OSOPTION
08972                                 cout << "First object is NULL, second is not" << endl;
08973                         #endif
08974                         return false;
08975                 }
08976         }
08977         else 
08978         {       if (that == NULL)
08979                 {
08980                         #ifdef DEBUG_OSOPTION
08981                                 cout << "Second object is NULL, first is not" << endl;
08982                         #endif
08983                         return false;
08984                 }
08985                 else    
08986                 {       if (this->numberOfVar != that->numberOfVar)  
08987                         {
08988 #ifdef DEBUG_OSOPTION
08989                                 cout << "numberOfVar: " << this->numberOfVar << " vs. " << that->numberOfVar << endl;
08990 #endif  
08991                                 return false;
08992                         }
08993                         int i;
08994                         for (i = 0; i < numberOfVar; i++)
08995                                 if (!this->var[i]->IsEqual(that->var[i]))
08996                                         return false;
08997                         return true;
08998                 }
08999         }
09000 }//InitVariableValues::IsEqual
09001 
09002 bool InitVarValue::IsEqual(InitVarValue *that)
09003 {
09004 #ifdef DEBUG_OSOPTION
09005         cout << "Start comparing in InitVarValue" << endl;
09006 #endif
09007         if (this == NULL)
09008         {       if (that == NULL)
09009                         return true;
09010                 else
09011                 {
09012                         #ifdef DEBUG_OSOPTION
09013                                 cout << "First object is NULL, second is not" << endl;
09014                         #endif
09015                         return false;
09016                 }
09017         }
09018         else 
09019         {       if (that == NULL)
09020                 {
09021                         #ifdef DEBUG_OSOPTION
09022                                 cout << "Second object is NULL, first is not" << endl;
09023                         #endif
09024                         return false;
09025                 }
09026                 else    
09027                 {       if ((this->idx != that->idx) || !isEqual(this->value, that->value))
09028                         {
09029 #ifdef DEBUG_OSOPTION
09030                                 cout << "idx: "   << this->idx   << " vs. " << that->idx   << endl;
09031                                 cout << "value: " << this->value << " vs. " << that->value << endl;
09032 #endif  
09033                                 return false;
09034                         }
09035                         return true;
09036                 }
09037         }
09038 }//InitVarValue::IsEqual
09039 
09040 
09041 bool InitVariableValuesString::IsEqual(InitVariableValuesString *that)
09042 {
09043 #ifdef DEBUG_OSOPTION
09044         cout << "Start comparing in InitVariableValuesString" << endl;
09045 #endif
09046         if (this == NULL)
09047         {       if (that == NULL)
09048                         return true;
09049                 else
09050                 {
09051                         #ifdef DEBUG_OSOPTION
09052                                 cout << "First object is NULL, second is not" << endl;
09053                         #endif
09054                         return false;
09055                 }
09056         }
09057         else 
09058         {       if (that == NULL)
09059                 {
09060                         #ifdef DEBUG_OSOPTION
09061                                 cout << "Second object is NULL, first is not" << endl;
09062                         #endif
09063                         return false;
09064                 }
09065                 else    
09066                 {       if (this->numberOfVar != that->numberOfVar)  
09067                         {
09068 #ifdef DEBUG_OSOPTION
09069                                 cout << "numberOfVar: " << this->numberOfVar << " vs. " << that->numberOfVar << endl;
09070 #endif  
09071                                 return false;
09072                         }
09073                         int i;
09074                         for (i = 0; i < numberOfVar; i++)
09075                                 if (!this->var[i]->IsEqual(that->var[i]))
09076                                         return false;
09077                         return true;
09078                 }
09079         }
09080 }//InitVariableValuesString::IsEqual
09081 
09082 bool InitVarValueString::IsEqual(InitVarValueString *that)
09083 {
09084 #ifdef DEBUG_OSOPTION
09085         cout << "Start comparing in InitVarValueString" << endl;
09086 #endif
09087         if (this == NULL)
09088         {       if (that == NULL)
09089                         return true;
09090                 else
09091                 {
09092                         #ifdef DEBUG_OSOPTION
09093                                 cout << "First object is NULL, second is not" << endl;
09094                         #endif
09095                         return false;
09096                 }
09097         }
09098         else 
09099         {       if (that == NULL)
09100                 {
09101                         #ifdef DEBUG_OSOPTION
09102                                 cout << "Second object is NULL, first is not" << endl;
09103                         #endif
09104                         return false;
09105                 }
09106                 else    
09107                 {       if ((this->idx != that->idx) || (this->value != that->value))
09108                         {
09109 #ifdef DEBUG_OSOPTION
09110                                 cout << "idx: "   << this->idx   << " vs. " << that->idx   << endl;
09111                                 cout << "value: " << this->value << " vs. " << that->value << endl;
09112 #endif  
09113                                 return false;
09114                         }
09115                         return true;
09116                 }
09117         }
09118 }//InitVarValueString::IsEqual
09119 
09120 bool InitialBasisStatus::IsEqual(InitialBasisStatus *that)
09121 {
09122 #ifdef DEBUG_OSOPTION
09123         cout << "Start comparing in InitialBasisStatus" << endl;
09124 #endif
09125         if (this == NULL)
09126         {       if (that == NULL)
09127                         return true;
09128                 else
09129                 {
09130                         #ifdef DEBUG_OSOPTION
09131                                 cout << "First object is NULL, second is not" << endl;
09132                         #endif
09133                         return false;
09134                 }
09135         }
09136         else 
09137         {       if (that == NULL)
09138                 {
09139                         #ifdef DEBUG_OSOPTION
09140                                 cout << "Second object is NULL, first is not" << endl;
09141                         #endif
09142                         return false;
09143                 }
09144                 else    
09145                 {       if (this->numberOfVar != that->numberOfVar)  
09146                         {
09147 #ifdef DEBUG_OSOPTION
09148                                 cout << "numberOfVar: " << this->numberOfVar << " vs. " << that->numberOfVar << endl;
09149 #endif  
09150                                 return false;
09151                         }
09152                         int i;
09153                         for (i = 0; i < numberOfVar; i++)
09154                                 if (!this->var[i]->IsEqual(that->var[i]))
09155                                         return false;
09156                         return true;
09157                 }
09158         }
09159 }//InitialBasisStatus::IsEqual
09160 
09161 bool InitBasStatus::IsEqual(InitBasStatus *that)
09162 {
09163 #ifdef DEBUG_OSOPTION
09164         cout << "Start comparing in InitBasStatus" << endl;
09165 #endif
09166         if (this == NULL)
09167         {       if (that == NULL)
09168                         return true;
09169                 else
09170                 {
09171                         #ifdef DEBUG_OSOPTION
09172                                 cout << "First object is NULL, second is not" << endl;
09173                         #endif
09174                         return false;
09175                 }
09176         }
09177         else 
09178         {       if (that == NULL)
09179                 {
09180                         #ifdef DEBUG_OSOPTION
09181                                 cout << "Second object is NULL, first is not" << endl;
09182                         #endif
09183                         return false;
09184                 }
09185                 else    
09186                 {       if ((this->idx != that->idx) || (this->value != that->value))
09187                         if ((this->value != "unknown" && that->value != "") ||
09188                                 (that->value != "unknown" && this->value != "") )
09189                         {
09190 #ifdef DEBUG_OSOPTION
09191                                 cout << "idx: "   << this->idx   << " vs. " << that->idx   << endl;
09192                                 cout << "value: " << this->value << " vs. " << that->value << endl;
09193 #endif  
09194                                 return false;
09195                         }
09196                         return true;
09197                 }
09198         }
09199 }//InitBasStatus::IsEqual
09200 
09201 
09202 bool IntegerVariableBranchingWeights::IsEqual(IntegerVariableBranchingWeights *that)
09203 {
09204 #ifdef DEBUG_OSOPTION
09205         cout << "Start comparing in IntegerVariableBranchingWeights" << endl;
09206 #endif
09207         if (this == NULL)
09208         {       if (that == NULL)
09209                         return true;
09210                 else
09211                 {
09212                         #ifdef DEBUG_OSOPTION
09213                                 cout << "First object is NULL, second is not" << endl;
09214                         #endif
09215                         return false;
09216                 }
09217         }
09218         else 
09219         {       if (that == NULL)
09220                 {
09221                         #ifdef DEBUG_OSOPTION
09222                                 cout << "Second object is NULL, first is not" << endl;
09223                         #endif
09224                         return false;
09225                 }
09226                 else    
09227                 {       if (this->numberOfVar != that->numberOfVar)  
09228                         {
09229 #ifdef DEBUG_OSOPTION
09230                                 cout << "numberOfVar: " << this->numberOfVar << " vs. " << that->numberOfVar << endl;
09231 #endif  
09232                                 return false;
09233                         }
09234                         int i;
09235                         for (i = 0; i < numberOfVar; i++)
09236                                 if (!this->var[i]->IsEqual(that->var[i]))
09237                                         return false;
09238                         return true;
09239                 }
09240         }
09241 }//IntegerVariableBranchingWeights::IsEqual
09242 
09243 bool SOSVariableBranchingWeights::IsEqual(SOSVariableBranchingWeights *that)
09244 {
09245 #ifdef DEBUG_OSOPTION
09246         cout << "Start comparing in SOSVariableBranchingWeights" << endl;
09247 #endif
09248         if (this == NULL)
09249         {       if (that == NULL)
09250                         return true;
09251                 else
09252                 {
09253                         #ifdef DEBUG_OSOPTION
09254                                 cout << "First object is NULL, second is not" << endl;
09255                         #endif
09256                         return false;
09257                 }
09258         }
09259         else 
09260         {       if (that == NULL)
09261                 {
09262                         #ifdef DEBUG_OSOPTION
09263                                 cout << "Second object is NULL, first is not" << endl;
09264                         #endif
09265                         return false;
09266                 }
09267                 else    
09268                 {       if (this->numberOfSOS != that->numberOfSOS)  
09269                         {
09270 #ifdef DEBUG_OSOPTION
09271                                 cout << "numberOfSOS: " << this->numberOfSOS << " vs. " << that->numberOfSOS << endl;
09272 #endif  
09273                                 return false;
09274                         }
09275                         int i;
09276                         for (i = 0; i < numberOfSOS; i++)
09277                         {       
09278                                 if (!this->sos[i]->IsEqual(that->sos[i]))
09279                                         return false;
09280                         }
09281                         return true;
09282                 }
09283         }
09284 }//SOSVariableBranchingWeights::IsEqual
09285 
09286 
09287 bool SOSWeights::IsEqual(SOSWeights *that)
09288 {
09289 #ifdef DEBUG_OSOPTION
09290         cout << "Start comparing in SOSWeights" << endl;
09291 #endif
09292         if (this == NULL)
09293         {       if (that == NULL)
09294                         return true;
09295                 else
09296                 {
09297                         #ifdef DEBUG_OSOPTION
09298                                 cout << "First object is NULL, second is not" << endl;
09299                         #endif
09300                         return false;
09301                 }
09302         }
09303         else 
09304         {       if (that == NULL)
09305                 {
09306                         #ifdef DEBUG_OSOPTION
09307                                 cout << "Second object is NULL, first is not" << endl;
09308                         #endif
09309                         return false;
09310                 }
09311                 else    
09312                 {       if ((this->sosIdx != that->sosIdx) ||
09313                                 !isEqual(this->groupWeight, that->groupWeight))  
09314                         {
09315 #ifdef DEBUG_OSOPTION
09316                                 cout << "sosIdx: "      << this->sosIdx      << " vs. " << that->sosIdx      << endl;
09317                                 cout << "groupWeight: " << this->groupWeight << " vs. " << that->groupWeight << endl;
09318 #endif  
09319                                 return false;
09320                         }
09321 
09322                         if (this->numberOfVar != that->numberOfVar)  
09323                         {
09324 #ifdef DEBUG_OSOPTION
09325                                 cout << "numberOfVar: " << this->numberOfVar << " vs. " << that->numberOfVar << endl;
09326 #endif  
09327                                 return false;
09328                         }
09329                         int i;
09330                         for (i = 0; i < numberOfVar; i++)
09331                         {       //cout << "var[" << i << "] of " << numberOfVar << endl;
09332                                 if (!this->var[i]->IsEqual(that->var[i]))
09333                                         return false;
09334                         }
09335                         return true;
09336                 }
09337         }
09338 }//SOSWeights::IsEqual
09339 
09340 
09341 bool BranchingWeight::IsEqual(BranchingWeight *that)
09342 {
09343 #ifdef DEBUG_OSOPTION
09344         cout << "Start comparing in BranchingWeight" << endl;
09345 #endif
09346         if (this == NULL)
09347         {       if (that == NULL)
09348                         return true;
09349                 else
09350                 {
09351                         #ifdef DEBUG_OSOPTION
09352                                 cout << "First object is NULL, second is not" << endl;
09353                         #endif
09354                         return false;
09355                 }
09356         }
09357         else 
09358         {       if (that == NULL)
09359                 {
09360                         #ifdef DEBUG_OSOPTION
09361                                 cout << "Second object is NULL, first is not" << endl;
09362                         #endif
09363                         return false;
09364                 }
09365                 else    
09366                 {       if ((this->idx != that->idx) || !isEqual(this->value, that->value))
09367                         {
09368 #ifdef DEBUG_OSOPTION
09369                                 cout << "idx: "   << this->idx   << " vs. " << that->idx   << endl;
09370                                 cout << "value: " << this->value << " vs. " << that->value << endl;
09371 #endif  
09372                                 return false;
09373                         }
09374                         return true;
09375                 }
09376         }
09377 }//BranchingWeight::IsEqual
09378 
09379 bool OtherVariableOption::IsEqual(OtherVariableOption *that)
09380 {
09381 #ifdef DEBUG_OSOPTION
09382         cout << "Start comparing in OtherVariableOption" << endl;
09383 #endif
09384         if (this == NULL)
09385         {       if (that == NULL)
09386                         return true;
09387                 else
09388                 {
09389                         #ifdef DEBUG_OSOPTION
09390                                 cout << "First object is NULL, second is not" << endl;
09391                         #endif
09392                         return false;
09393                 }
09394         }
09395         else 
09396         {       if (that == NULL)
09397                 {
09398                         #ifdef DEBUG_OSOPTION
09399                                 cout << "Second object is NULL, first is not" << endl;
09400                         #endif
09401                         return false;
09402                 }
09403                 else    
09404                 {       if ((this->name        != that->name)     ||
09405                                 (this->value       != that->value)    ||
09406                                 (this->solver      != that->solver)   ||
09407                                 (this->category    != that->category) ||
09408                                 (this->type        != that->type)     ||
09409                                 (this->description != that->description))  
09410                         {
09411 #ifdef DEBUG_OSOPTION
09412                                 cout << "name: "        << this->name        << " vs. " << that->name        << endl;
09413                                 cout << "value: "       << this->value       << " vs. " << that->value       << endl;
09414                                 cout << "solver: "      << this->solver      << " vs. " << that->solver      << endl;
09415                                 cout << "category: "    << this->category    << " vs. " << that->category    << endl;
09416                                 cout << "type: "        << this->type        << " vs. " << that->type        << endl;
09417                                 cout << "description: " << this->description << " vs. " << that->description << endl;
09418 #endif  
09419                                 return false;
09420                         }
09421 
09422                         if (this->numberOfVar != that->numberOfVar)  
09423                         {
09424 #ifdef DEBUG_OSOPTION
09425                                 cout << "numberOfVar: " << this->numberOfVar << " vs. " << that->numberOfVar << endl;
09426 #endif  
09427                                 return false;
09428                         }
09429                         int i;
09430                         for (i = 0; i < numberOfVar; i++)
09431                                 if (!this->var[i]->IsEqual(that->var[i]))
09432                                         return false;
09433 
09434                         if (this->numberOfEnumerations != that->numberOfEnumerations)  
09435                         {
09436 #ifdef DEBUG_OSOPTION
09437                                 cout << "numberOfEnumerations: " << this->numberOfEnumerations << " vs. " << that->numberOfEnumerations << endl;
09438 #endif  
09439                                 return false;
09440                         }
09441                         for (i = 0; i < numberOfEnumerations; i++)
09442                                 if (!this->enumeration[i]->IsEqual(that->enumeration[i]))
09443                                         return false;
09444                         return true;
09445                 }
09446         }
09447 }//OtherVariableOption::IsEqual
09448 
09449 bool OtherVarOption::IsEqual(OtherVarOption *that)
09450 {
09451 #ifdef DEBUG_OSOPTION
09452         cout << "Start comparing in OtherVarOption" << endl;
09453 #endif
09454         if (this == NULL)
09455         {       if (that == NULL)
09456                         return true;
09457                 else
09458                 {
09459                         #ifdef DEBUG_OSOPTION
09460                                 cout << "First object is NULL, second is not" << endl;
09461                         #endif
09462                         return false;
09463                 }
09464         }
09465         else 
09466         {       if (that == NULL)
09467                 {
09468                         #ifdef DEBUG_OSOPTION
09469                                 cout << "Second object is NULL, first is not" << endl;
09470                         #endif
09471                         return false;
09472                 }
09473                 else    
09474                 {       if ((this->idx     != that->idx)     || (this->value   != that->value) ||
09475                                 (this->lbValue != that->lbValue) || (this->ubValue != that->ubValue))
09476                         {
09477 #ifdef DEBUG_OSOPTION
09478                                 cout << "idx: "     << this->idx     << " vs. " << that->idx     << endl;
09479                                 cout << "value: "   << this->value   << " vs. " << that->value   << endl;
09480                                 cout << "lbValue: " << this->lbValue << " vs. " << that->lbValue << endl;
09481                                 cout << "ubValue: " << this->ubValue << " vs. " << that->ubValue << endl;
09482 #endif  
09483                                 return false;
09484                         }
09485                         return true;
09486                 }
09487         }
09488 }//OtherVarOption::IsEqual
09489 
09490 bool ObjectiveOption::IsEqual(ObjectiveOption *that)
09491 {
09492 #ifdef DEBUG_OSOPTION
09493         cout << "Start comparing in ObjectiveOption" << endl;
09494 #endif
09495         if (this == NULL)
09496         {       if (that == NULL)
09497                         return true;
09498                 else
09499                 {
09500                         #ifdef DEBUG_OSOPTION
09501                                 cout << "First object is NULL, second is not" << endl;
09502                         #endif
09503                         return false;
09504                 }
09505         }
09506         else 
09507         {       if (that == NULL)
09508                 {
09509                         #ifdef DEBUG_OSOPTION
09510                                 cout << "Second object is NULL, first is not" << endl;
09511                         #endif
09512                         return false;
09513                 }
09514                 else    
09515                 {       
09516                         if (!this->initialObjectiveValues->IsEqual(that->initialObjectiveValues))
09517                                 return false;
09518                         if (!this->initialObjectiveBounds->IsEqual(that->initialObjectiveBounds))
09519                                 return false;
09520                         if (!this->initialBasisStatus->IsEqual(that->initialBasisStatus))
09521                                 return false;
09522 
09523                         if (this->numberOfOtherObjectiveOptions != that->numberOfOtherObjectiveOptions)  
09524                         {
09525 #ifdef DEBUG_OSOPTION
09526                                 cout << "numberOfOtherObjectiveOptions: " << this->numberOfOtherObjectiveOptions << " vs. " << that->numberOfOtherObjectiveOptions << endl;
09527 #endif  
09528                                 return false;
09529                         }
09530                         int i;
09531                         for (i = 0; i < numberOfOtherObjectiveOptions; i++)
09532                                 if (!this->other[i]->IsEqual(that->other[i]))
09533                                         return false;
09534 
09535                         return true;
09536                 }
09537         }
09538 }//ObjectiveOption::IsEqual
09539 
09540 bool InitObjectiveValues::IsEqual(InitObjectiveValues *that)
09541 {
09542 #ifdef DEBUG_OSOPTION
09543         cout << "Start comparing in InitObjectiveValues" << endl;
09544 #endif
09545         if (this == NULL)
09546         {       if (that == NULL)
09547                         return true;
09548                 else
09549                 {
09550                         #ifdef DEBUG_OSOPTION
09551                                 cout << "First object is NULL, second is not" << endl;
09552                         #endif
09553                         return false;
09554                 }
09555         }
09556         else 
09557         {       if (that == NULL)
09558                 {
09559                         #ifdef DEBUG_OSOPTION
09560                                 cout << "Second object is NULL, first is not" << endl;
09561                         #endif
09562                         return false;
09563                 }
09564                 else    
09565                 {       if (this->numberOfObj != that->numberOfObj)  
09566                         {
09567 #ifdef DEBUG_OSOPTION
09568                                 cout << "numberOfObj: " << this->numberOfObj << " vs. " << that->numberOfObj << endl;
09569 #endif  
09570                                 return false;
09571                         }
09572                         int i;
09573                         for (i = 0; i < numberOfObj; i++)
09574                                 if (!this->obj[i]->IsEqual(that->obj[i]))
09575                                         return false;
09576                         return true;
09577                 }
09578         }
09579 }//InitObjectiveValues::IsEqual
09580 
09581 bool InitObjValue::IsEqual(InitObjValue *that)
09582 {
09583 #ifdef DEBUG_OSOPTION
09584         cout << "Start comparing in InitObjValue" << endl;
09585 #endif
09586         if (this == NULL)
09587         {       if (that == NULL)
09588                         return true;
09589                 else
09590                 {
09591                         #ifdef DEBUG_OSOPTION
09592                                 cout << "First object is NULL, second is not" << endl;
09593                         #endif
09594                         return false;
09595                 }
09596         }
09597         else 
09598         {       if (that == NULL)
09599                 {
09600                         #ifdef DEBUG_OSOPTION
09601                                 cout << "Second object is NULL, first is not" << endl;
09602                         #endif
09603                         return false;
09604                 }
09605                 else    
09606                 {       if ((this->idx != that->idx) || !isEqual(this->value, that->value))
09607                         {
09608 #ifdef DEBUG_OSOPTION
09609                                 cout << "idx: "   << this->idx   << " vs. " << that->idx   << endl;
09610                                 cout << "value: " << this->value << " vs. " << that->value << endl;
09611 #endif  
09612                                 return false;
09613                         }
09614                         return true;
09615                 }
09616         }
09617 }//InitObjValue::IsEqual
09618 
09619 bool InitObjectiveBounds::IsEqual(InitObjectiveBounds *that)
09620 {
09621 #ifdef DEBUG_OSOPTION
09622         cout << "Start comparing in InitObjectiveBounds" << endl;
09623 #endif
09624         if (this == NULL)
09625         {       if (that == NULL)
09626                         return true;
09627                 else
09628                 {
09629                         #ifdef DEBUG_OSOPTION
09630                                 cout << "First object is NULL, second is not" << endl;
09631                         #endif
09632                         return false;
09633                 }
09634         }
09635         else 
09636         {       if (that == NULL)
09637                 {
09638                         #ifdef DEBUG_OSOPTION
09639                                 cout << "Second object is NULL, first is not" << endl;
09640                         #endif
09641                         return false;
09642                 }
09643                 else    
09644                 {       if (this->numberOfObj != that->numberOfObj)  
09645                         {
09646 #ifdef DEBUG_OSOPTION
09647                                 cout << "numberOfObj: " << this->numberOfObj << " vs. " << that->numberOfObj << endl;
09648 #endif  
09649                                 return false;
09650                         }
09651                         int i;
09652                         for (i = 0; i < numberOfObj; i++)
09653                                 if (!this->obj[i]->IsEqual(that->obj[i]))
09654                                         return false;
09655                         return true;
09656                 }
09657         }
09658 }//InitObjectiveBounds::IsEqual
09659 
09660 bool InitObjBound::IsEqual(InitObjBound *that)
09661 {
09662 #ifdef DEBUG_OSOPTION
09663         cout << "Start comparing in InitObjBound" << endl;
09664 #endif
09665         if (this == NULL)
09666         {       if (that == NULL)
09667                         return true;
09668                 else
09669                 {
09670                         #ifdef DEBUG_OSOPTION
09671                                 cout << "First object is NULL, second is not" << endl;
09672                         #endif
09673                         return false;
09674                 }
09675         }
09676         else 
09677         {       if (that == NULL)
09678                 {
09679                         #ifdef DEBUG_OSOPTION
09680                                 cout << "Second object is NULL, first is not" << endl;
09681                         #endif
09682                         return false;
09683                 }
09684                 else    
09685                 {       if ((this->idx     != that->idx)    || !isEqual(this->lbValue,that->lbValue) || 
09686                                 !isEqual(this->ubValue, that->ubValue) )
09687                         {
09688 #ifdef DEBUG_OSOPTION
09689                                 cout << "idx: "     << this->idx     << " vs. " << that->idx     << endl;
09690                                 cout << "lbValue: " << this->lbValue << " vs. " << that->lbValue << endl;
09691                                 cout << "ubValue: " << this->ubValue << " vs. " << that->ubValue << endl;
09692 #endif  
09693                                 return false;
09694                         }
09695                         return true;
09696                 }
09697         }
09698 }//InitObjBound::IsEqual
09699 
09700 bool OtherObjectiveOption::IsEqual(OtherObjectiveOption *that)
09701 {
09702 #ifdef DEBUG_OSOPTION
09703         cout << "Start comparing in OtherObjectiveOption" << endl;
09704 #endif
09705         if (this == NULL)
09706         {       if (that == NULL)
09707                         return true;
09708                 else
09709                 {
09710                         #ifdef DEBUG_OSOPTION
09711                                 cout << "First object is NULL, second is not" << endl;
09712                         #endif
09713                         return false;
09714                 }
09715         }
09716         else 
09717         {       if (that == NULL)
09718                 {
09719                         #ifdef DEBUG_OSOPTION
09720                                 cout << "Second object is NULL, first is not" << endl;
09721                         #endif
09722                         return false;
09723                 }
09724                 else    
09725                 {       if ((this->name        != that->name)     ||
09726                                 (this->value       != that->value)    ||
09727                                 (this->solver      != that->solver)   ||
09728                                 (this->category    != that->category) ||
09729                                 (this->type        != that->type)     ||
09730                                 (this->description != that->description))  
09731                         {
09732 #ifdef DEBUG_OSOPTION
09733                                 cout << "name: "        << this->name        << " vs. " << that->name        << endl;
09734                                 cout << "value: "       << this->value       << " vs. " << that->value       << endl;
09735                                 cout << "solver: "      << this->solver      << " vs. " << that->solver      << endl;
09736                                 cout << "category: "    << this->category    << " vs. " << that->category    << endl;
09737                                 cout << "type: "        << this->type        << " vs. " << that->type        << endl;
09738                                 cout << "description: " << this->description << " vs. " << that->description << endl;
09739 #endif  
09740                                 return false;
09741                         }
09742 
09743                         if (this->numberOfObj != that->numberOfObj)  
09744                         {
09745 #ifdef DEBUG_OSOPTION
09746                                 cout << "numberOfObj: " << this->numberOfObj << " vs. " << that->numberOfObj << endl;
09747 #endif  
09748                                 return false;
09749                         }
09750                         int i;
09751                         for (i = 0; i < numberOfObj; i++)
09752                                 if (!this->obj[i]->IsEqual(that->obj[i]))
09753                                         return false;
09754                         return true;
09755                 }
09756         }
09757 }//OtherObjectiveOption::IsEqual
09758 
09759 bool OtherObjOption::IsEqual(OtherObjOption *that)
09760 {
09761 #ifdef DEBUG_OSOPTION
09762         cout << "Start comparing in OtherObjOption" << endl;
09763 #endif
09764         if (this == NULL)
09765         {       if (that == NULL)
09766                         return true;
09767                 else
09768                 {
09769                         #ifdef DEBUG_OSOPTION
09770                                 cout << "First object is NULL, second is not" << endl;
09771                         #endif
09772                         return false;
09773                 }
09774         }
09775         else 
09776         {       if (that == NULL)
09777                 {
09778                         #ifdef DEBUG_OSOPTION
09779                                 cout << "Second object is NULL, first is not" << endl;
09780                         #endif
09781                         return false;
09782                 }
09783                 else    
09784                 {       if ((this->idx     != that->idx)     || (this->value   != that->value) ||
09785                                 (this->lbValue != that->lbValue) || (this->ubValue != that->ubValue))
09786                         {
09787 #ifdef DEBUG_OSOPTION
09788                                 cout << "idx: "     << this->idx     << " vs. " << that->idx     << endl;
09789                                 cout << "value: "   << this->value   << " vs. " << that->value   << endl;
09790                                 cout << "lbValue: " << this->lbValue << " vs. " << that->lbValue << endl;
09791                                 cout << "ubValue: " << this->ubValue << " vs. " << that->ubValue << endl;
09792 #endif  
09793                                 return false;
09794                         }
09795                         return true;
09796                 }
09797         }
09798 }//OtherObjOption::IsEqual
09799 
09800 bool ConstraintOption::IsEqual(ConstraintOption *that)
09801 {
09802 #ifdef DEBUG_OSOPTION
09803         cout << "Start comparing in ConstraintOption" << endl;
09804 #endif
09805         if (this == NULL)
09806         {       if (that == NULL)
09807                         return true;
09808                 else
09809                 {
09810                         #ifdef DEBUG_OSOPTION
09811                                 cout << "First object is NULL, second is not" << endl;
09812                         #endif
09813                         return false;
09814                 }
09815         }
09816         else 
09817         {       if (that == NULL)
09818                 {
09819                         #ifdef DEBUG_OSOPTION
09820                                 cout << "Second object is NULL, first is not" << endl;
09821                         #endif
09822                         return false;
09823                 }
09824                 else    
09825                 {       
09826                         if (!this->initialConstraintValues->IsEqual(that->initialConstraintValues))
09827                                 return false;
09828                         if (!this->initialDualValues->IsEqual(that->initialDualValues))
09829                                 return false;
09830                         if (!this->initialBasisStatus->IsEqual(that->initialBasisStatus))
09831                                 return false;
09832 
09833                         if (this->numberOfOtherConstraintOptions != that->numberOfOtherConstraintOptions)  
09834                         {
09835 #ifdef DEBUG_OSOPTION
09836                                 cout << "numberOfOtherConstraintOptions: " << this->numberOfOtherConstraintOptions << " vs. " << that->numberOfOtherConstraintOptions << endl;
09837 #endif  
09838                                 return false;
09839                         }
09840                         int i;
09841                         for (i = 0; i < numberOfOtherConstraintOptions; i++)
09842                                 if (!this->other[i]->IsEqual(that->other[i]))
09843                                         return false;
09844 
09845                         return true;
09846                 }
09847         }
09848 }//ConstraintOption::IsEqual
09849 
09850 bool InitConstraintValues::IsEqual(InitConstraintValues *that)
09851 {
09852 #ifdef DEBUG_OSOPTION
09853         cout << "Start comparing in InitConstraintValues" << endl;
09854 #endif
09855         if (this == NULL)
09856         {       if (that == NULL)
09857                         return true;
09858                 else
09859                 {
09860                         #ifdef DEBUG_OSOPTION
09861                                 cout << "First object is NULL, second is not" << endl;
09862                         #endif
09863                         return false;
09864                 }
09865         }
09866         else 
09867         {       if (that == NULL)
09868                 {
09869                         #ifdef DEBUG_OSOPTION
09870                                 cout << "Second object is NULL, first is not" << endl;
09871                         #endif
09872                         return false;
09873                 }
09874                 else    
09875                 {       if (this->numberOfCon != that->numberOfCon)  
09876                         {
09877 #ifdef DEBUG_OSOPTION
09878                                 cout << "numberOfCon: " << this->numberOfCon << " vs. " << that->numberOfCon << endl;
09879 #endif  
09880                                 return false;
09881                         }
09882                         int i;
09883                         for (i = 0; i < numberOfCon; i++)
09884                                 if (!this->con[i]->IsEqual(that->con[i]))
09885                                         return false;
09886                         return true;
09887                 }
09888         }
09889 }//InitConstraintValues::IsEqual
09890 
09891 bool InitConValue::IsEqual(InitConValue *that)
09892 {
09893 #ifdef DEBUG_OSOPTION
09894         cout << "Start comparing in InitConValue" << endl;
09895 #endif
09896         if (this == NULL)
09897         {       if (that == NULL)
09898                         return true;
09899                 else
09900                 {
09901                         #ifdef DEBUG_OSOPTION
09902                                 cout << "First object is NULL, second is not" << endl;
09903                         #endif
09904                         return false;
09905                 }
09906         }
09907         else 
09908         {       if (that == NULL)
09909                 {
09910                         #ifdef DEBUG_OSOPTION
09911                                 cout << "Second object is NULL, first is not" << endl;
09912                         #endif
09913                         return false;
09914                 }
09915                 else    
09916                 {       if ((this->idx != that->idx) || !isEqual(this->value, that->value))
09917                         {
09918 #ifdef DEBUG_OSOPTION
09919                                 cout << "idx: "   << this->idx   << " vs. " << that->idx   << endl;
09920                                 cout << "value: " << this->value << " vs. " << that->value << endl;
09921 #endif  
09922                                 return false;
09923                         }
09924                         return true;
09925                 }
09926         }
09927 }//InitConValue::IsEqual
09928 
09929 bool InitDualVariableValues::IsEqual(InitDualVariableValues *that)
09930 {
09931 #ifdef DEBUG_OSOPTION
09932         cout << "Start comparing in InitDualVariableValues" << endl;
09933 #endif
09934         if (this == NULL)
09935         {       if (that == NULL)
09936                         return true;
09937                 else
09938                 {
09939                         #ifdef DEBUG_OSOPTION
09940                                 cout << "First object is NULL, second is not" << endl;
09941                         #endif
09942                         return false;
09943                 }
09944         }
09945         else 
09946         {       if (that == NULL)
09947                 {
09948                         #ifdef DEBUG_OSOPTION
09949                                 cout << "Second object is NULL, first is not" << endl;
09950                         #endif
09951                         return false;
09952                 }
09953                 else    
09954                 {       if (this->numberOfCon != that->numberOfCon)  
09955                         {
09956 #ifdef DEBUG_OSOPTION
09957                                 cout << "numberOfCon: " << this->numberOfCon << " vs. " << that->numberOfCon << endl;
09958 #endif  
09959                                 return false;
09960                         }
09961                         int i;
09962                         for (i = 0; i < numberOfCon; i++)
09963                                 if (!this->con[i]->IsEqual(that->con[i]))
09964                                         return false;
09965                         return true;
09966                 }
09967         }
09968 }//InitDualVariableValues::IsEqual
09969 
09970 bool InitDualVarValue::IsEqual(InitDualVarValue *that)
09971 {
09972 #ifdef DEBUG_OSOPTION
09973         cout << "Start comparing in InitDualVarValue" << endl;
09974 #endif
09975         if (this == NULL)
09976         {       if (that == NULL)
09977                         return true;
09978                 else
09979                 {
09980                         #ifdef DEBUG_OSOPTION
09981                                 cout << "First object is NULL, second is not" << endl;
09982                         #endif
09983                         return false;
09984                 }
09985         }
09986         else 
09987         {       if (that == NULL)
09988                 {
09989                         #ifdef DEBUG_OSOPTION
09990                                 cout << "Second object is NULL, first is not" << endl;
09991                         #endif
09992                         return false;
09993                 }
09994                 else    
09995                 {       if ((this->idx != that->idx) || !isEqual(this->lbDualValue, that->lbDualValue) ||
09996                                                         !isEqual(this->ubDualValue, that->ubDualValue))
09997                         {
09998 #ifdef DEBUG_OSOPTION
09999                                 cout << "idx: "         << this->idx         << " vs. " << that->idx         << endl;
10000                                 cout << "lbDualValue: " << this->lbDualValue << " vs. " << that->lbDualValue << endl;
10001                                 cout << "ubDualValue: " << this->ubDualValue << " vs. " << that->ubDualValue << endl;
10002 #endif  
10003                                 return false;
10004                         }
10005                         return true;
10006                 }
10007         }
10008 }//InitDualVarValue::IsEqual
10009 
10010 bool OtherConstraintOption::IsEqual(OtherConstraintOption *that)
10011 {
10012 #ifdef DEBUG_OSOPTION
10013         cout << "Start comparing in OtherConstraintOption" << endl;
10014 #endif
10015         if (this == NULL)
10016         {       if (that == NULL)
10017                         return true;
10018                 else
10019                 {
10020                         #ifdef DEBUG_OSOPTION
10021                                 cout << "First object is NULL, second is not" << endl;
10022                         #endif
10023                         return false;
10024                 }
10025         }
10026         else 
10027         {       if (that == NULL)
10028                 {
10029                         #ifdef DEBUG_OSOPTION
10030                                 cout << "Second object is NULL, first is not" << endl;
10031                         #endif
10032                         return false;
10033                 }
10034                 else    
10035                 {       if ((this->name        != that->name)     ||
10036                                 (this->value       != that->value)    ||
10037                                 (this->solver      != that->solver)   ||
10038                                 (this->category    != that->category) ||
10039                                 (this->type        != that->type)     ||
10040                                 (this->description != that->description))  
10041                         {
10042 #ifdef DEBUG_OSOPTION
10043                                 cout << "name: "        << this->name        << " vs. " << that->name        << endl;
10044                                 cout << "value: "       << this->value       << " vs. " << that->value       << endl;
10045                                 cout << "solver: "      << this->solver      << " vs. " << that->solver      << endl;
10046                                 cout << "category: "    << this->category    << " vs. " << that->category    << endl;
10047                                 cout << "type: "        << this->type        << " vs. " << that->type        << endl;
10048                                 cout << "description: " << this->description << " vs. " << that->description << endl;
10049 #endif  
10050                                 return false;
10051                         }
10052 
10053                         if (this->numberOfCon != that->numberOfCon)  
10054                         {
10055 #ifdef DEBUG_OSOPTION
10056                                 cout << "numberOfCon: " << this->numberOfCon << " vs. " << that->numberOfCon << endl;
10057 #endif  
10058                                 return false;
10059                         }
10060                         int i;
10061                         for (i = 0; i < numberOfCon; i++)
10062                                 if (!this->con[i]->IsEqual(that->con[i]))
10063                                         return false;
10064                         return true;
10065                 }
10066         }
10067 }//OtherConstraintOption::IsEqual
10068 
10069 bool OtherConOption::IsEqual(OtherConOption *that)
10070 {
10071 #ifdef DEBUG_OSOPTION
10072         cout << "Start comparing in OtherConOption" << endl;
10073 #endif
10074         if (this == NULL)
10075         {       if (that == NULL)
10076                         return true;
10077                 else
10078                 {
10079                         #ifdef DEBUG_OSOPTION
10080                                 cout << "First object is NULL, second is not" << endl;
10081                         #endif
10082                         return false;
10083                 }
10084         }
10085         else 
10086         {       if (that == NULL)
10087                 {
10088                         #ifdef DEBUG_OSOPTION
10089                                 cout << "Second object is NULL, first is not" << endl;
10090                         #endif
10091                         return false;
10092                 }
10093                 else    
10094                 {       if ((this->idx     != that->idx)     || (this->value   != that->value) ||
10095                                 (this->lbValue != that->lbValue) || (this->ubValue != that->ubValue))
10096                         {
10097 #ifdef DEBUG_OSOPTION
10098                                 cout << "idx: "     << this->idx     << " vs. " << that->idx     << endl;
10099                                 cout << "value: "   << this->value   << " vs. " << that->value   << endl;
10100                                 cout << "lbValue: " << this->lbValue << " vs. " << that->lbValue << endl;
10101                                 cout << "ubValue: " << this->ubValue << " vs. " << that->ubValue << endl;
10102 #endif  
10103                                 return false;
10104                         }
10105                         return true;
10106                 }
10107         }
10108 }//OtherConOption::IsEqual
10109 
10110 
10111 bool SolverOptions::IsEqual(SolverOptions *that)
10112 {
10113 #ifdef DEBUG_OSOPTION
10114         cout << "Start comparing in SolverOptions" << endl;
10115 #endif
10116         if (this == NULL)
10117         {       if (that == NULL)
10118                         return true;
10119                 else
10120                 {
10121                         #ifdef DEBUG_OSOPTION
10122                                 cout << "First object is NULL, second is not" << endl;
10123                         #endif
10124                         return false;
10125                 }
10126         }
10127         else 
10128         {       if (that == NULL)
10129                 {
10130                         #ifdef DEBUG_OSOPTION
10131                                 cout << "Second object is NULL, first is not" << endl;
10132                         #endif
10133                         return false;
10134                 }
10135                 else    
10136                 {   if (this->numberOfSolverOptions != that->numberOfSolverOptions)  
10137                         {
10138 #ifdef DEBUG_OSOPTION
10139                                 cout << "numberOfSolverOptions: " << this->numberOfSolverOptions << " vs. " << that->numberOfSolverOptions << endl;
10140 #endif  
10141                                 return false;
10142                         }
10143 
10144                         int i;
10145                         for (i = 0; i < numberOfSolverOptions; i++)
10146                                 if (!this->solverOption[i]->IsEqual(that->solverOption[i]))
10147                                         return false;
10148 
10149                         return true;
10150                 }
10151         }
10152 }//SolverOptions::IsEqual
10153 
10154 bool SolverOption::IsEqual(SolverOption *that )
10155 {
10156 #ifdef DEBUG_OSOPTION
10157         cout << "Start comparing in SolverOption" << endl;
10158 #endif
10159         if (this == NULL)
10160         {       if (that == NULL)
10161                         return true;
10162                 else
10163                 {
10164                         #ifdef DEBUG_OSOPTION
10165                                 cout << "First object is NULL, second is not" << endl;
10166                         #endif
10167                         return false;
10168                 }
10169         }
10170         else 
10171         {       if (that == NULL)
10172                 {
10173                         #ifdef DEBUG_OSOPTION
10174                                 cout << "Second object is NULL, first is not" << endl;
10175                         #endif
10176                         return false;
10177                 }
10178                 else    
10179                 {       if ((this->name        != that->name)     ||
10180                                 (this->value       != that->value)    ||
10181                                 (this->solver      != that->solver)   ||
10182                                 (this->category    != that->category) ||
10183                                 (this->type        != that->type)     ||
10184                                 (this->description != that->description))  
10185                         {
10186 #ifdef DEBUG_OSOPTION
10187                                 cout << "name: "        << this->name        << " vs. " << that->name        << endl;
10188                                 cout << "value: "       << this->value       << " vs. " << that->value       << endl;
10189                                 cout << "solver: "      << this->solver      << " vs. " << that->solver      << endl;
10190                                 cout << "category: "    << this->category    << " vs. " << that->category    << endl;
10191                                 cout << "type: "        << this->type        << " vs. " << that->type        << endl;
10192                                 cout << "description: " << this->description << " vs. " << that->description << endl;
10193 #endif  
10194                                 return false;
10195                         }
10196                         return true;
10197                 }
10198         }
10199 }//SolverOption::IsEqual
10200 
10201 
10202 /***********************************************************************
10203  *
10204  * Methods to set a random OSOption object.
10205  *
10206  * These methods are mostly useful during the debugging process 
10207  * but might come in handy in other ways
10208  * The calling sequence is identical in all cases: setRandom( double density, bool conformant ) 
10209  * @param density gives the probability that a particular child element is generated
10210  * @param conformant controls whether side constraints (such as agreement of "numberOfChildren" 
10211  *      attributes with the number of <child> elements) should be enforced (conformant=true) or not
10212  *
10213  ***********************************************************************/
10214 bool OSOption::setRandom( double density, bool conformant )
10215 {
10216 #ifdef DEBUG_OSOPTION
10217         cout << "Set random OSOption" << endl;
10218 #endif
10219         if (OSRand() <= density)
10220         {
10221                 optionHeader = new GeneralFileHeader();
10222                 optionHeader->setRandom(density, conformant);
10223         }
10224         if (OSRand() <= density)
10225         {
10226                 general = new GeneralOption();
10227                 general->setRandom(density, conformant);
10228         }
10229         if (OSRand() <= density)       
10230         {
10231                 system = new SystemOption();
10232                 system->setRandom(density, conformant);
10233         }
10234         if (OSRand() <= density)      
10235         {
10236                 service = new ServiceOption();
10237                 service->setRandom(density, conformant);
10238         }
10239         if (OSRand() <= density)          
10240         {
10241                 job = new JobOption();
10242                 job->setRandom(density, conformant);
10243         }
10244         if (OSRand() <= density) 
10245         {
10246                 optimization = new OptimizationOption();
10247                 optimization->setRandom(density, conformant);
10248         }
10249         return true;
10250 }//OSOption::setRandom
10251 
10252 
10253 bool GeneralOption::setRandom( double density, bool conformant )
10254 {       
10255 #ifdef DEBUG_OSOPTION
10256         cout << "Set random GeneralOption" << endl;
10257 #endif
10258         if (OSRand() <= density) this->serviceURI     = "random string";
10259         if (OSRand() <= density) this->serviceName    = "random string";
10260         if (OSRand() <= density) this->instanceName   = "random string";
10261         if (OSRand() <= density) this->jobID          = "random string";
10262         if (OSRand() <= density) this->solverToInvoke = "random string";
10263         if (OSRand() <= density) this->license        = "random string";
10264         if (OSRand() <= density) this->userName       = "random string";
10265         if (OSRand() <= density) this->password       = "random string";
10266 
10267         if (OSRand() <= density)
10268         {
10269                 instanceLocation = new InstanceLocationOption(); 
10270                 instanceLocation->setRandom(density, conformant);
10271         }
10272         if (OSRand() <= density)          
10273         {
10274                 contact = new ContactOption(); 
10275                 contact->setRandom(density, conformant);
10276         }
10277         if (OSRand() <= density)     
10278         {
10279                 otherOptions = new OtherOptions(); 
10280                 otherOptions->setRandom(density, conformant);
10281         }
10282         return true;
10283 }//GeneralOption::setRandom
10284 
10285 
10286 bool SystemOption::setRandom( double density, bool conformant )
10287 {       
10288 #ifdef DEBUG_OSOPTION
10289         cout << "Set random SystemOption" << endl;
10290 #endif
10291         if (OSRand() <= density)  
10292         {
10293                 minDiskSpace = new StorageCapacity(); 
10294                 minDiskSpace->setRandom(density, conformant);
10295         }
10296         if (OSRand() <= density) 
10297         {
10298                 minMemorySize = new StorageCapacity(); 
10299                 minMemorySize->setRandom(density, conformant);
10300         }
10301         if (OSRand() <= density)   
10302         {
10303                 minCPUSpeed = new CPUSpeed(); 
10304                 minCPUSpeed->setRandom(density, conformant);
10305         }
10306         if (OSRand() <= density)  
10307         {
10308                 minCPUNumber = new CPUNumber(); 
10309                 minCPUNumber->setRandom(density, conformant);
10310         }
10311         if (OSRand() <= density)     
10312         {
10313                 otherOptions = new OtherOptions(); 
10314                 otherOptions->setRandom(density, conformant);
10315         }
10316         return true;
10317 }//SystemOption::setRandom
10318 
10319 
10320 bool ServiceOption::setRandom( double density, bool conformant )
10321 {       
10322 #ifdef DEBUG_OSOPTION
10323         cout << "Set random ServiceOption" << endl;
10324 #endif
10325         if (OSRand() <= density) 
10326         {
10327                 double temp = OSRand();
10328                 if (conformant) temp = 0.5*temp;
10329 
10330                 if      (temp <= 0.25) this->type = "solver";
10331                 else if (temp <= 0.50) this->type = "agent";
10332                 else if (temp <= 0.75) this->type = "";
10333                 else                   this->type = "spy";
10334         } 
10335 
10336         if (OSRand() <= density)  
10337         {
10338                 otherOptions = new OtherOptions(); 
10339                 otherOptions->setRandom(density, conformant);
10340         }
10341         return true;
10342 }//ServiceOption::setRandom
10343 
10344 
10345 bool JobOption::setRandom( double density, bool conformant )
10346 {
10347 #ifdef DEBUG_OSOPTION
10348         cout << "Set random JobOption" << endl;
10349 #endif
10350         if (OSRand() <= density) this->requestedStartTime = "1997-08-11T01:23:45-09:13";
10351 
10352         if (OSRand() <= density)                 
10353         {
10354                 maxTime = new TimeSpan(); 
10355                 maxTime->setRandom(density, conformant);
10356         }
10357         if (OSRand() <= density)            
10358         {
10359                 dependencies = new JobDependencies(); 
10360                 dependencies->setRandom(density, conformant);
10361         }
10362         if (OSRand() <= density)     
10363         {
10364                 requiredDirectories = new DirectoriesAndFiles(); 
10365                 requiredDirectories->setRandom(density, conformant);
10366         }
10367         if (OSRand() <= density)           
10368         {
10369                 requiredFiles = new DirectoriesAndFiles(); 
10370                 requiredFiles->setRandom(density, conformant);
10371         }
10372         if (OSRand() <= density)       
10373         {
10374                 directoriesToMake = new DirectoriesAndFiles(); 
10375                 directoriesToMake->setRandom(density, conformant);
10376         }
10377         if (OSRand() <= density)             
10378         {
10379                 filesToMake = new DirectoriesAndFiles(); 
10380                 filesToMake->setRandom(density, conformant);
10381         }
10382         if (OSRand() <= density)  
10383         {
10384                 inputDirectoriesToMove = new PathPairs(); 
10385                 inputDirectoriesToMove->setRandom(density, conformant);
10386         }
10387         if (OSRand() <= density)        
10388         {
10389                 inputFilesToMove = new PathPairs(); 
10390                 inputFilesToMove->setRandom(density, conformant);
10391         }
10392         if (OSRand() <= density)       
10393         {
10394                 outputFilesToMove = new PathPairs(); 
10395                 outputFilesToMove->setRandom(density, conformant);
10396         }
10397         if (OSRand() <= density) 
10398         {
10399                 outputDirectoriesToMove = new PathPairs(); 
10400                 outputDirectoriesToMove->setRandom(density, conformant);
10401         }
10402         if (OSRand() <= density)           
10403         {
10404                 filesToDelete = new DirectoriesAndFiles(); 
10405                 filesToDelete->setRandom(density, conformant);
10406         }
10407         if (OSRand() <= density)     
10408         {
10409                 directoriesToDelete = new DirectoriesAndFiles(); 
10410                 directoriesToDelete->setRandom(density, conformant);
10411         }
10412         if (OSRand() <= density)         
10413         {
10414                 processesToKill = new Processes(); 
10415                 processesToKill->setRandom(density, conformant);
10416         }
10417         if (OSRand() <= density)
10418         {
10419                 otherOptions = new OtherOptions(); 
10420                 otherOptions->setRandom(density, conformant);
10421         }
10422         return true;
10423 }//JobOption::setRandom
10424 
10425 bool OptimizationOption::setRandom( double density, bool conformant )
10426 {
10427 #ifdef DEBUG_OSOPTION
10428         cout << "Set random OptimizationOption" << endl;
10429 #endif
10430         if (OSRand() <= density && !conformant) this->numberOfVariables   = (int)(1+9*OSRand());
10431         if (OSRand() <= density && !conformant) this->numberOfObjectives  = (int)(1+9*OSRand());
10432         if (OSRand() <= density && !conformant) this->numberOfConstraints = (int)(1+9*OSRand());
10433 
10434         if (OSRand() <= density)    
10435         {
10436                 variables = new VariableOption(); 
10437                 variables->setRandom(density, conformant);
10438         }
10439         if (OSRand() <= density)    
10440         {
10441                 objectives = new ObjectiveOption(); 
10442                 objectives->setRandom(density, conformant);
10443         }
10444         if (OSRand() <= density)   
10445         {
10446                 constraints = new ConstraintOption(); 
10447                 constraints->setRandom(density, conformant);
10448         }
10449         if (OSRand() <= density) 
10450         {
10451                 solverOptions = new SolverOptions(); 
10452                 solverOptions->setRandom(density, conformant);
10453         }
10454 
10455         return true;
10456 }//OptimizationOption::setRandom
10457 
10458 bool InstanceLocationOption::setRandom( double density, bool conformant )
10459 {
10460 #ifdef DEBUG_OSOPTION
10461         cout << "Set random InstanceLocationOption" << endl;
10462 #endif
10463         if (OSRand() <= density) this->value = "http://www.google.com";
10464         if (OSRand() <= density) 
10465         {
10466                 double temp = OSRand();
10467                 if (conformant) temp = 0.5*temp;
10468 
10469                 if      (temp <= 0.25) this->locationType = "local";
10470                 else if (temp <= 0.50) this->locationType = "ftp";
10471                 else if (temp <= 0.75) this->locationType = "";
10472                 else                   this->locationType = "global";
10473         } 
10474         return true;
10475 }//InstanceLocationOption::setRandom
10476 
10477 bool ContactOption::setRandom( double density, bool conformant )
10478 {
10479 #ifdef DEBUG_OSOPTION
10480         cout << "Set random ContactOption" << endl;
10481 #endif
10482         if (OSRand() <= density) this->value = "http://www.google.com";
10483         if (OSRand() <= density) 
10484         {
10485                 double temp = OSRand();
10486                 if (conformant) temp = 0.5*temp;
10487 
10488                 if      (temp <= 0.25) this->transportType = "osp";
10489                 else if (temp <= 0.50) this->transportType = "ftp";
10490                 else if (temp <= 0.75) this->transportType = "";
10491                 else                   this->transportType = "nlp";
10492         } 
10493         return true;
10494 }//ContactOption::setRandom
10495 
10496 bool OtherOptions::setRandom( double density, bool conformant )
10497 {
10498 #ifdef DEBUG_OSOPTION
10499         cout << "Set random OtherOptions" << endl;
10500 #endif
10501         int n;
10502 
10503         this->numberOfOtherOptions = (int)(1+4*OSRand());
10504 
10505         if (conformant) n = this->numberOfOtherOptions;
10506         else            n = (int)(1+4*OSRand());
10507 
10508         other = new OtherOption*[n];
10509 
10510         for (int i = 0; i < n; i++)
10511         {
10512                 other[i] = new OtherOption();
10513                 other[i]->setRandom(density, conformant);
10514         }
10515 
10516         return true;
10517 }//OtherOptions::setRandom
10518 
10519 bool OtherOption::setRandom( double density, bool conformant )
10520 {
10521 #ifdef DEBUG_OSOPTION
10522         cout << "Set random OtherOption" << endl;
10523 #endif
10524         if (OSRand() <= density || conformant) this->name = "random string"; 
10525         if (OSRand() <= density) this->value       = "random string"; 
10526         if (OSRand() <= density) this->description = "random string"; 
10527         return true;
10528 }//OtherOption::setRandom
10529 
10530 
10531 
10532 bool JobDependencies::setRandom( double density, bool conformant )
10533 {
10534 #ifdef DEBUG_OSOPTION
10535         cout << "Set random JobDependencies" << endl;
10536 #endif
10537         int n;
10538 
10539         this->numberOfJobIDs = (int)(1+4*OSRand());
10540 
10541         if (conformant) n = this->numberOfJobIDs;
10542         else            n = (int)(1+4*OSRand());
10543 
10544         jobID = new std::string[n];
10545         for (int i = 0; i < n; i++)
10546                 jobID[i] = "random string";
10547 
10548         return true;
10549 }//JobDependencies::setRandom
10550 
10551 bool DirectoriesAndFiles::setRandom( double density, bool conformant )
10552 {
10553 #ifdef DEBUG_OSOPTION
10554         cout << "Set random DirectoriesAndFiles" << endl;
10555 #endif
10556         int n;
10557 
10558         this->numberOfPaths = (int)(1+4*OSRand());
10559 
10560         if (conformant) n = this->numberOfPaths;
10561         else            n = (int)(1+4*OSRand());
10562 
10563         path = new std::string[n];
10564         for (int i = 0; i < n; i++)
10565                 path[i] = "random string";
10566 
10567         return true;
10568 }//DirectoriesAndFiles::setRandom
10569 
10570 bool PathPairs::setRandom( double density, bool conformant )
10571 {
10572 #ifdef DEBUG_OSOPTION
10573         cout << "Set random PathPairs" << endl;
10574 #endif
10575         int n;
10576 
10577         this->numberOfPathPairs = (int)(1+4*OSRand());
10578 
10579         if (conformant) n = this->numberOfPathPairs;
10580         else            n =(int)(1+4*OSRand());
10581 
10582         pathPair = new PathPair*[n];
10583         for (int i = 0; i < n; i++)
10584         {
10585                 this->pathPair[i] = new PathPair();
10586                 this->pathPair[i]->setRandom(density, conformant);
10587         }
10588 
10589         return true;
10590 }//PathPairs::setRandom
10591 
10592 bool PathPair::setRandom( double density, bool conformant )
10593 {
10594 #ifdef DEBUG_OSOPTION
10595         cout << "Set random PathPair" << endl;
10596 #endif
10597         this->from = "random string";
10598         this->to   = "random string";
10599         if (OSRand() <= density) this->makeCopy = (OSRand() <= 0.5);
10600         return true;
10601 }//PathPair::setRandom
10602 
10603 bool Processes::setRandom( double density, bool conformant )
10604 {
10605 #ifdef DEBUG_OSOPTION
10606         cout << "Set random Processes" << endl;
10607 #endif
10608         int n;
10609 
10610         this->numberOfProcesses = (int)(1+4*OSRand());
10611 
10612         if (conformant) n = this->numberOfProcesses;
10613         else            n = (int)(1+4*OSRand());
10614 
10615         process = new std::string[n];   
10616         for (int i = 0; i < n; i++)
10617                 process[i] = "random string";
10618 
10619         return true;
10620 }//Processes::setRandom
10621 
10622 bool VariableOption::setRandom( double density, bool conformant )
10623 {
10624 #ifdef DEBUG_OSOPTION
10625         cout << "Set random VariableOption" << endl;
10626 #endif
10627         if (OSRand() <= density) 
10628         {
10629                 this->initialVariableValues = new InitVariableValues();
10630                 this->initialVariableValues->setRandom(density, conformant);
10631         }
10632                                 return false;
10633         if (OSRand() <= density) 
10634         {
10635                 this->initialVariableValuesString = new InitVariableValuesString();
10636                 this->initialVariableValuesString->setRandom(density, conformant);
10637         }
10638         if (OSRand() <= density) 
10639         {
10640                 this->initialBasisStatus = new BasisStatus();
10641                 this->initialBasisStatus->setRandom(density, conformant, 0, 9);
10642         }
10643         if (OSRand() <= density) 
10644         {
10645                 this->integerVariableBranchingWeights = new IntegerVariableBranchingWeights();
10646                 this->integerVariableBranchingWeights->setRandom(density, conformant);
10647         }
10648         if (OSRand() <= density) 
10649         {
10650                 this->sosVariableBranchingWeights = new SOSVariableBranchingWeights();
10651                 this->sosVariableBranchingWeights->setRandom(density, conformant);
10652         }
10653 
10654 
10655         this->numberOfOtherVariableOptions = (int)(4*OSRand());
10656 
10657         int n;
10658 
10659         if (conformant) n = this->numberOfOtherVariableOptions;
10660         else            n = (int)(4*OSRand());
10661 
10662         other = new OtherVariableOption*[n];    
10663         for (int i = 0; i < n; i++)
10664         {
10665                 other[i] = new OtherVariableOption();
10666                 other[i]->setRandom(density, conformant);
10667         }
10668         return true;
10669 }//VariableOption::setRandom
10670 
10671 bool InitVariableValues::setRandom( double density, bool conformant )
10672 {
10673 #ifdef DEBUG_OSOPTION
10674         cout << "Set random InitVariableValues" << endl;
10675 #endif
10676         this->numberOfVar = (int)(1+4*OSRand());
10677 
10678         int n;
10679 
10680         if (conformant) n = this->numberOfVar;
10681         else            n = (int)(1+4*OSRand());
10682 
10683         var = new InitVarValue*[n];     
10684         for (int i = 0; i < n; i++)
10685         {
10686                 var[i] = new InitVarValue();
10687                 var[i]->setRandom(density, conformant);
10688         }
10689         return true;
10690 }//InitVariableValues::setRandom
10691 
10692 bool InitVarValue::setRandom( double density, bool conformant )
10693 {
10694 #ifdef DEBUG_OSOPTION
10695         cout << "Set random InitVarValue" << endl;
10696 #endif
10697         this->idx = (int)(4*OSRand());
10698 
10699         if (OSRand() <= density) 
10700         {
10701                 if (OSRand() <= 0.5) this->value = 3.14156;
10702                 else                 this->value = 2.71828;
10703         }
10704         return true;
10705 }//InitVarValue::setRandom
10706 
10707 
10708 bool InitVariableValuesString::setRandom( double density, bool conformant )
10709 {
10710 #ifdef DEBUG_OSOPTION
10711         cout << "Set random InitVariableValuesString" << endl;
10712 #endif
10713         this->numberOfVar = (int)(1+4*OSRand());
10714 
10715         int n;
10716 
10717         if (conformant) n = this->numberOfVar;
10718         else            n = (int)(1+4*OSRand());
10719 
10720         var = new InitVarValueString*[n];       
10721         for (int i = 0; i < n; i++)
10722         {
10723                 var[i] = new InitVarValueString();
10724                 var[i]->setRandom(density, conformant);
10725         }
10726         return true;
10727 }//InitVariableValuesString::setRandom
10728 
10729 bool InitVarValueString::setRandom( double density, bool conformant )
10730 {
10731 #ifdef DEBUG_OSOPTION
10732         cout << "Set random InitVarValueString" << endl;
10733 #endif
10734         this->idx = (int)(4*OSRand());
10735 
10736         if (OSRand() <= density) this->value = "random string";
10737 
10738         return true;
10739 }//InitVarValueString::setRandom
10740 
10741 
10742 bool IntegerVariableBranchingWeights::setRandom( double density, bool conformant )
10743 {
10744 #ifdef DEBUG_OSOPTION
10745         cout << "Set random IntegerVariableBranchingWeights" << endl;
10746 #endif
10747         this->numberOfVar = (int)(1+4*OSRand());
10748 
10749         int n;
10750 
10751         if (conformant) n = this->numberOfVar;
10752         else            n = (int)(1+4*OSRand());
10753 
10754         var = new BranchingWeight*[n];  
10755         for (int i = 0; i < n; i++)
10756         {
10757                 var[i] = new BranchingWeight();
10758                 var[i]->setRandom(density, conformant);
10759         }
10760         return true;
10761 }//IntegerVariableBranchingWeights::setRandom
10762 
10763 bool SOSVariableBranchingWeights::setRandom( double density, bool conformant )
10764 {
10765 #ifdef DEBUG_OSOPTION
10766         cout << "Set random SOSVariableBranchingWeights" << endl;
10767 #endif
10768         this->numberOfSOS = (int)(1+4*OSRand());
10769 
10770         int n;
10771 
10772         if (conformant) n = this->numberOfSOS;
10773         else            n = (int)(1+4*OSRand());
10774 
10775         sos = new SOSWeights*[n];       
10776         for (int i = 0; i < n; i++)
10777         {
10778                 sos[i] = new SOSWeights();
10779                 sos[i]->setRandom(density, conformant);
10780         }
10781         return true;
10782 }//SOSVariableBranchingWeights::setRandom
10783 
10784 
10785 bool SOSWeights::setRandom( double density, bool conformant )
10786 {
10787 #ifdef DEBUG_OSOPTION
10788         cout << "Set random SOSWeights" << endl;
10789 #endif
10790         this->sosIdx      = (int)(4*OSRand());
10791         this->numberOfVar = (int)(4*OSRand());
10792 
10793         if (OSRand() <= density) this->groupWeight = OSRand();
10794 
10795 
10796         int n;
10797 
10798         if (conformant) n = this->numberOfVar;
10799         else            n = (int)(4*OSRand());
10800 
10801         var = new BranchingWeight*[n];  
10802         for (int i = 0; i < n; i++)
10803         {
10804                 var[i] = new BranchingWeight();
10805                 var[i]->setRandom(density, conformant);
10806         }
10807         return true;
10808 }//SOSWeights::setRandom
10809 
10810 
10811 bool BranchingWeight::setRandom( double density, bool conformant )
10812 {
10813 #ifdef DEBUG_OSOPTION
10814         cout << "Set random BranchingWeight" << endl;
10815 #endif
10816         this->idx = (int)(4*OSRand());
10817 
10818         if (OSRand() <= density) 
10819                 this->value = OSRand();
10820         return true;
10821 }//BranchingWeight::setRandom
10822 
10823 bool OtherVariableOption::setRandom( double density, bool conformant )
10824 {
10825 #ifdef DEBUG_OSOPTION
10826         cout << "Set random OtherVariableOption" << endl;
10827 #endif
10828         this->name = "random string";
10829         if (OSRand() <= density) this->name        = "randon string";
10830         if (OSRand() <= density) this->value       = "randon string";
10831         if (OSRand() <= density) this->solver      = "randon string";
10832         if (OSRand() <= density) this->category    = "randon string";
10833         if (OSRand() <= density) this->type        = "randon string";
10834         if (OSRand() <= density) this->description = "randon string";
10835 
10836         if (OSRand() <= density) 
10837         {
10838                 if (OSRand() <= 0.5)
10839                 {
10840                         this->numberOfVar = (int)(4*OSRand());
10841 
10842                         int n;
10843 
10844                         if (conformant) n = this->numberOfVar;
10845                         else            n = (int)(4*OSRand());
10846 
10847                         var = new OtherVarOption*[n];   
10848                         for (int i = 0; i < n; i++)
10849                         {
10850                                 var[i] = new OtherVarOption();
10851                                 var[i]->setRandom(density, conformant);
10852                         }
10853                 }
10854                 else
10855                 {
10856                         this->numberOfEnumerations = (int)(4*OSRand());
10857 
10858                         int n;
10859 
10860                         if (conformant) n = this->numberOfEnumerations;
10861                         else            n = (int)(4*OSRand());
10862 
10863                         enumeration = new OtherOptionEnumeration*[n];   
10864                         for (int i = 0; i < n; i++)
10865                         {
10866                                 enumeration[i] = new OtherOptionEnumeration();
10867                                 enumeration[i]->setRandom(density, conformant, 0, 9);
10868                         }
10869                 }
10870         }
10871         return true;
10872 }//OtherVariableOption::setRandom
10873 
10874 bool OtherVarOption::setRandom( double density, bool conformant )
10875 {
10876 #ifdef DEBUG_OSOPTION
10877         cout << "Set random OtherVarOption" << endl;
10878 #endif
10879         this->idx = (int)(4*OSRand());
10880         if (OSRand() <= density) this->value =   "random string";
10881         if (OSRand() <= density) this->lbValue = "random string";
10882         if (OSRand() <= density) this->ubValue = "random string";
10883         return true;
10884 }//OtherVarOption::setRandom
10885 
10886 bool ObjectiveOption::setRandom( double density, bool conformant )
10887 {
10888 #ifdef DEBUG_OSOPTION
10889         cout << "Set random ObjectiveOption" << endl;
10890 #endif
10891         if (OSRand() <= density) 
10892         {
10893                 this->initialObjectiveValues = new InitObjectiveValues();
10894                 this->initialObjectiveValues->setRandom(density, conformant);
10895         }
10896                                 return false;
10897         if (OSRand() <= density) 
10898         {
10899                 this->initialObjectiveBounds = new InitObjectiveBounds();
10900                 this->initialObjectiveBounds->setRandom(density, conformant);
10901         }
10902         if (OSRand() <= density) 
10903         {
10904                 this->initialBasisStatus = new BasisStatus();
10905                 this->initialBasisStatus->setRandom(density, conformant, -2, -1);
10906         }
10907 
10908         if (OSRand() <= density) 
10909         {
10910                 this->numberOfOtherObjectiveOptions = (int)(4*OSRand());
10911 
10912                 int n;
10913 
10914                 if (conformant) n = this->numberOfOtherObjectiveOptions;
10915                 else            n = (int)(4*OSRand());
10916 
10917                 other = new OtherObjectiveOption*[n];   
10918                 for (int i = 0; i < n; i++)
10919                 {
10920                         other[i] = new OtherObjectiveOption();
10921                         other[i]->setRandom(density, conformant);
10922                 }
10923         }
10924         return true;
10925 }//ObjectiveOption::setRandom
10926 
10927 bool InitObjectiveValues::setRandom( double density, bool conformant )
10928 {
10929 #ifdef DEBUG_OSOPTION
10930         cout << "Set random InitObjectiveValues" << endl;
10931 #endif
10932         this->numberOfObj = (int)(1+4*OSRand());
10933 
10934         int n;
10935 
10936         if (conformant) n = this->numberOfObj;
10937         else            n = (int)(1+4*OSRand());
10938 
10939         obj = new InitObjValue*[n];     
10940         for (int i = 0; i < n; i++)
10941         {
10942                 obj[i] = new InitObjValue();
10943                 obj[i]->setRandom(density, conformant);
10944         }
10945         return true;
10946 }//InitObjectiveValues::setRandom
10947 
10948 bool InitObjValue::setRandom( double density, bool conformant )
10949 {
10950 #ifdef DEBUG_OSOPTION
10951         cout << "Set random InitObjValue" << endl;
10952 #endif
10953         if (OSRand() <= 0.5) idx = -1;
10954         else                 idx = -2;
10955 
10956         if (OSRand() <= density) 
10957         {
10958                 if (OSRand() <= 0.5) this->value = 3.14156;
10959                 else                 this->value = 2.71828;
10960         }
10961         return true;
10962 }//InitObjValue::setRandom
10963 
10964 bool InitObjectiveBounds::setRandom( double density, bool conformant )
10965 {
10966 #ifdef DEBUG_OSOPTION
10967         cout << "Set random InitObjectiveBounds" << endl;
10968 #endif
10969         this->numberOfObj = (int)(1+4*OSRand());
10970 
10971         int n;
10972 
10973         if (conformant) n = this->numberOfObj;
10974         else            n = (int)(1+4*OSRand());
10975 
10976         obj = new InitObjBound*[n];     
10977         for (int i = 0; i < n; i++)
10978         {
10979                 obj[i] = new InitObjBound();
10980                 obj[i]->setRandom(density, conformant);
10981         }
10982         return true;
10983 }//InitObjectiveBounds::setRandom
10984 
10985 bool InitObjBound::setRandom( double density, bool conformant )
10986 {
10987 #ifdef DEBUG_OSOPTION
10988         cout << "Set random InitObjBound" << endl;
10989 #endif
10990         if (OSRand() <= 0.5) idx = -1;
10991         else                 idx = -2;
10992 
10993         if (OSRand() <= density) 
10994         {
10995                 if (OSRand() <= 0.5) this->lbValue = 3.14156;
10996                 else                 this->lbValue = 2.71828;
10997                 if (OSRand() <= 0.5) this->ubValue = 3.14156;
10998                 else                 this->ubValue = 2.71828;
10999         }
11000         return true;
11001 }//InitObjBound::setRandom
11002 
11003 bool OtherObjectiveOption::setRandom( double density, bool conformant )
11004 {
11005 #ifdef DEBUG_OSOPTION
11006         cout << "Set random OtherObjectiveOption" << endl;
11007 #endif
11008         this->name = "random string";
11009         if (OSRand() <= density) this->name        = "randon string";
11010         if (OSRand() <= density) this->value       = "randon string";
11011         if (OSRand() <= density) this->solver      = "randon string";
11012         if (OSRand() <= density) this->category    = "randon string";
11013         if (OSRand() <= density) this->type        = "randon string";
11014         if (OSRand() <= density) this->description = "randon string";
11015 
11016         if (OSRand() <= density) 
11017         {
11018                 if (OSRand() <= 0.5)
11019                 {
11020                         this->numberOfObj = (int)(4*OSRand());
11021 
11022                         int n;
11023 
11024                         if (conformant) n = this->numberOfObj;
11025                         else            n = (int)(4*OSRand());
11026 
11027                         obj = new OtherObjOption*[n];   
11028                         for (int i = 0; i < n; i++)
11029                         {
11030                                 obj[i] = new OtherObjOption();
11031                                 obj[i]->setRandom(density, conformant);
11032                         }
11033                 }
11034                 else
11035                 {
11036                         this->numberOfEnumerations = (int)(4*OSRand());
11037 
11038                         int n;
11039 
11040                         if (conformant) n = this->numberOfEnumerations;
11041                         else            n = (int)(4*OSRand());
11042 
11043                         enumeration = new OtherOptionEnumeration*[n];   
11044                         for (int i = 0; i < n; i++)
11045                         {
11046                                 enumeration[i] = new OtherOptionEnumeration();
11047                                 enumeration[i]->setRandom(density, conformant, -2, -1);
11048                         }
11049                 }
11050         }
11051         return true;
11052 }//OtherObjectiveOption::setRandom
11053 
11054 bool OtherObjOption::setRandom( double density, bool conformant )
11055 {
11056 #ifdef DEBUG_OSOPTION
11057         cout << "Set random OtherObjOption" << endl;
11058 #endif
11059         if (OSRand() <= 0.5) this->idx = -1;
11060         else                 this->idx = -2;
11061         if (OSRand() <= density) this->value =   "random string";
11062         if (OSRand() <= density) this->lbValue = "random string";
11063         if (OSRand() <= density) this->ubValue = "random string";
11064         return true;
11065 }//OtherObjOption::setRandom
11066 
11067 bool ConstraintOption::setRandom( double density, bool conformant )
11068 {
11069 #ifdef DEBUG_OSOPTION
11070         cout << "Set random ConstraintOption" << endl;
11071 #endif
11072         if (OSRand() <= density) 
11073         {
11074                 this->initialConstraintValues = new InitConstraintValues();
11075                 this->initialConstraintValues->setRandom(density, conformant);
11076         }
11077                                 return false;
11078         if (OSRand() <= density) 
11079         {
11080                 this->initialDualValues = new InitDualVariableValues();
11081                 this->initialDualValues->setRandom(density, conformant);
11082         }
11083         if (OSRand() <= density) 
11084         {
11085                 this->initialBasisStatus = new BasisStatus();
11086                 this->initialBasisStatus->setRandom(density, conformant, 0, 4);
11087         }
11088 
11089         if (OSRand() <= density) 
11090         {
11091                 this->numberOfOtherConstraintOptions = (int)(4*OSRand());
11092 
11093                 int n;
11094 
11095                 if (conformant) n = this->numberOfOtherConstraintOptions;
11096                 else            n = (int)(4*OSRand());
11097 
11098                 other = new OtherConstraintOption*[n];  
11099                 for (int i = 0; i < n; i++)
11100                 {
11101                         other[i] = new OtherConstraintOption();
11102                         other[i]->setRandom(density, conformant);
11103                 }
11104         }
11105         return true;
11106 }//ConstraintOption::setRandom
11107 
11108 bool InitConstraintValues::setRandom( double density, bool conformant )
11109 {
11110 #ifdef DEBUG_OSOPTION
11111         cout << "Set random InitConstraintValues" << endl;
11112 #endif
11113         this->numberOfCon = (int)(1+4*OSRand());
11114 
11115         int n;
11116 
11117         if (conformant) n = this->numberOfCon;
11118         else            n = (int)(1+4*OSRand());
11119 
11120         con = new InitConValue*[n];     
11121         for (int i = 0; i < n; i++)
11122         {
11123                 con[i] = new InitConValue();
11124                 con[i]->setRandom(density, conformant);
11125         }
11126         return true;
11127 }//InitConstraintValues::setRandom
11128 
11129 bool InitConValue::setRandom( double density, bool conformant )
11130 {
11131 #ifdef DEBUG_OSOPTION
11132         cout << "Set random InitConValue" << endl;
11133 #endif
11134         this->idx = (int)(4*OSRand());
11135 
11136         if (OSRand() <= density) 
11137         {
11138                 if (OSRand() <= 0.5) this->value = 3.14156;
11139                 else                 this->value = 2.71828;
11140         }
11141         return true;
11142 }//InitConValue::setRandom
11143 
11144 bool InitDualVariableValues::setRandom( double density, bool conformant )
11145 {
11146 #ifdef DEBUG_OSOPTION
11147         cout << "Set random InitDualVariableValues" << endl;
11148 #endif
11149         this->numberOfCon = (int)(1+4*OSRand());
11150 
11151         int n;
11152 
11153         if (conformant) n = this->numberOfCon;
11154         else            n = (int)(1+4*OSRand());
11155 
11156         con = new InitDualVarValue*[n]; 
11157         for (int i = 0; i < n; i++)
11158         {
11159                 con[i] = new InitDualVarValue();
11160                 con[i]->setRandom(density, conformant);
11161         }
11162         return true;
11163 }//InitDualVariableValues::setRandom
11164 
11165 bool InitDualVarValue::setRandom( double density, bool conformant )
11166 {
11167 #ifdef DEBUG_OSOPTION
11168         cout << "Set random InitDualVarValue" << endl;
11169 #endif
11170         this->idx = (int)(4*OSRand());
11171 
11172         if (OSRand() <= density) 
11173         {
11174                 if (OSRand() <= 0.5) this->lbDualValue = 3.14156;
11175                 else                 this->lbDualValue = 2.71828;
11176                 if (OSRand() <= 0.5) this->ubDualValue = 3.14156;
11177                 else                 this->ubDualValue = 2.71828;
11178         }
11179         return true;
11180 }//InitDualVarValue::setRandom
11181 
11182 bool OtherConstraintOption::setRandom( double density, bool conformant )
11183 {
11184 #ifdef DEBUG_OSOPTION
11185         cout << "Set random OtherConstraintOption" << endl;
11186 #endif
11187         this->name = "random string";
11188         if (OSRand() <= density) this->name        = "randon string";
11189         if (OSRand() <= density) this->value       = "randon string";
11190         if (OSRand() <= density) this->solver      = "randon string";
11191         if (OSRand() <= density) this->category    = "randon string";
11192         if (OSRand() <= density) this->type        = "randon string";
11193         if (OSRand() <= density) this->description = "randon string";
11194 
11195         if (OSRand() <= density) 
11196         {
11197                 if (OSRand() <= 0.5)
11198                 {
11199                         this->numberOfCon = (int)(4*OSRand());
11200 
11201                         int n;
11202 
11203                         if (conformant) n = this->numberOfCon;
11204                         else            n = (int)(4*OSRand());
11205 
11206                         con = new OtherConOption*[n];   
11207                         for (int i = 0; i < n; i++)
11208                         {
11209                                 con[i] = new OtherConOption();
11210                                 con[i]->setRandom(density, conformant);
11211                         }
11212                 }
11213                 else
11214                 {
11215                         this->numberOfEnumerations = (int)(4*OSRand());
11216 
11217                         int n;
11218 
11219                         if (conformant) n = this->numberOfEnumerations;
11220                         else            n = (int)(4*OSRand());
11221 
11222                         enumeration = new OtherOptionEnumeration*[n];   
11223                         for (int i = 0; i < n; i++)
11224                         {
11225                                 enumeration[i] = new OtherOptionEnumeration();
11226                                 enumeration[i]->setRandom(density, conformant, 0, 4);
11227                         }
11228                 }
11229         }
11230         return true;
11231 }//OtherConstraintOption::setRandom
11232 
11233 bool OtherConOption::setRandom( double density, bool conformant )
11234 {
11235 #ifdef DEBUG_OSOPTION
11236         cout << "Set random OtherConOption" << endl;
11237 #endif
11238         this->idx = (int)(4*OSRand());
11239         if (OSRand() <= density) this->value =   "random string";
11240         if (OSRand() <= density) this->lbValue = "random string";
11241         if (OSRand() <= density) this->ubValue = "random string";
11242         return true;
11243 }//OtherConOption::setRandom
11244 
11245 
11246 bool SolverOptions::setRandom( double density, bool conformant )
11247 {
11248 #ifdef DEBUG_OSOPTION
11249         cout << "Set random SolverOptions" << endl;
11250 #endif
11251         this->numberOfSolverOptions = (int)(1+4*OSRand());
11252 
11253         int n;
11254 
11255         if (conformant) n = this->numberOfSolverOptions;
11256         else            n = (int)(1+4*OSRand());
11257 
11258         solverOption = new SolverOption*[n];    
11259         for (int i = 0; i < n; i++)
11260         {
11261                 solverOption[i] = new SolverOption();
11262                 solverOption[i]->setRandom(density, conformant);
11263         }
11264         return true;
11265 }//SolverOptions::setRandom
11266 
11267 bool SolverOption::setRandom( double density, bool conformant )
11268 {
11269 #ifdef DEBUG_OSOPTION
11270         cout << "Set random SolverOption" << endl;
11271 #endif
11272         if (OSRand() <= density || conformant) this->name = "random string";
11273 
11274         if (OSRand() <= density) this->value       = "random string";
11275         if (OSRand() <= density) this->solver      = "random string";
11276         if (OSRand() <= density) this->category    = "random string";
11277         if (OSRand() <= density) this->type        = "random string";
11278         if (OSRand() <= density) this->description = "random string";
11279 
11280         if (OSRand() <= density)
11281         {
11282                 this->numberOfItems = (int)(4*OSRand());
11283 
11284                 int n;
11285 
11286                 if (conformant) n = this->numberOfItems;
11287                 else            n = (int)(4*OSRand());
11288 
11289                 item = new std::string[n];      
11290                 for (int i = 0; i < n; i++)
11291                         item[i] = "random string";
11292         }
11293         return true;
11294 }//SolverOption::setRandom

Generated on Thu Mar 31 03:12:56 2011 by  doxygen 1.4.7