- Main Page
- Namespaces
- Classes
- Files
- Related Pages

- File List
- File Members

# /home/coin/SVN-release/OS-2.3.5/OS/src/OSSolverService.cpp

Go to the documentation of this file.

    00001 //Id: OSSolverService.cpp 3561 2010-06-24 19:27:07Z kmartin $
    00069 #include "OSCoinSolver.h"
    00070 #include "OSResult.h"
    00071 #include "OSiLReader.h"
    00072 #include "OSiLWriter.h"
    00073 #include "OSoLReader.h"
    00074 #include "OSrLReader.h"
    00075 #include "OSrLWriter.h"
    00076 #include "OSInstance.h"
    00077 #include "OSOption.h"
    00078 #include "OSoLWriter.h"
    00079 #include "OSFileUtil.h"
    00080 #include "OSConfig.h"
    00081 #include "OSDefaultSolver.h"
    00082 #include "OSWSUtil.h"
    00083 #include "OSSolverAgent.h"
    00084 #include "OShL.h"
    00085 #include "OSErrorClass.h"
    00086 #include "OSmps2osil.h"
    00087 #include "OSBase64.h"
    00088
    00089 #ifdef COIN_HAS_KNITRO
    00090 #include "OSKnitroSolver.h"
    00091 #endif
    00092
    00093 #ifdef COIN_HAS_LINDO
    00094 #include "OSLindoSolver.h"
    00095 #endif
    00096
    00097 #ifdef COIN_HAS_ASL
    00098 #include "OSnl2osil.h"
    00099 #endif
    00100
    00101 #ifdef COIN_HAS_GAMSUTILS
    00102 #include "OSgams2osil.hpp"
    00103 #endif
    00104
    00105 //#ifdef COIN_HAS_IPOPT
    00106 //#include "OSIpoptSolver.h"
    00107 //#endif
    00108
    00109 #ifdef COIN_HAS_IPOPT
    00110 #ifndef COIN_HAS_ASL
    00111 #include "OSIpoptSolver.h"
    00112 #undef COIN_HAS_ASL
    00113 #else
    00114 #include "OSIpoptSolver.h"
    00115 #endif
    00116 #endif
    00117
    00118 #ifdef COIN_HAS_BONMIN
    00119 #include "OSBonminSolver.h"
    00120 #endif
    00121
    00122 #ifdef COIN_HAS_COUENNE
    00123 #include "OSCouenneSolver.h"
    00124 #endif
    00125
    00126 #include "OSOptionsStruc.h"
    00127
    00128 #include<stdio.h>
    00129 #include <map>
    00130
    00131
    00132 using std::cout;
    00133 using std::endl;
    00134 using std::ostringstream;
    00135 using std::string;
    00136 using std::map;
    00137
    00138 //#define DEBUG_CL_INTERFACE
    00139
    00140
    00141 #define MAXCHARS 5000
    00142
    00143 typedef struct yy_buffer_state *YY_BUFFER_STATE;
    00144 YY_BUFFER_STATE osss_scan_string(const char* osss, void* scanner);
    00145 //void osssset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
    00146 void setyyextra(osOptionsStruc *osoptions, void* scanner);
    00147 int ossslex(void* scanner);
    00148 int ossslex_init(void** ptr);
    00149 int ossslex_destroy(void* scanner);
    00150
    00151 std::string get_help();
    00152 std::string get_version();
    00153 std::string get_options();
    00154 void reset_options();
    00155
    00156 // the serviceMethods
    00157 void solve();
    00158 void getJobID();
    00159 void send();
    00160 void kill();
    00161 void retrieve();
    00162 void knock();
    00163
    00164 // additional methods
    00165 void getOSiLFromNl();
    00166 void getOSiLFromMps();
    00167 void getOSiLFromGams();
    00168 std::string buildSolver(std::string solverName, std::string osol,
    00169                 OSInstance *osinstance);
    00170 void listOptions(osOptionsStruc *osoptions);
    00171
    00172 //std::string getServiceURI( std::string osol);
    00173 //std::string getInstanceLocation( std::string osol);
    00174 //std::string getSolverName( std::string osol);
    00175 //std::string setSolverName( std::string osol, std::string solverName);
    00176
    00177
    00178 //options structure
    00179 // this is the only global variable but
    00180 // this is not a problem since this is a main routine
    00181 osOptionsStruc *osoptions;
    00182
    00183 int main(int argC, const char* argV[]) {
    00184         WindowsErrorPopupBlocker();
    00185         void* scanner;
    00186         FileUtil *fileUtil = NULL;
    00187         FileUtil *inputFileUtil = NULL;
    00188         char osss[MAXCHARS] = " ";
    00189         const char *space = " ";
    00190         //char *config = "-config";
    00191         std::string configFileName = "";
    00192         int i;
    00193
    00194         std::cout << getVersionInfo();
    00195
    00196         // initialize the OS options structure
    00197
    00198         osoptions = new osOptionsStruc();
    00199         reset_options();
    00200         bool scannerActive = false;
    00201
    00202         try {
    00203                 if (argC < 2) {
    00204                         //std::cout << "There must be at least one command line argument" << std::endl;
    00205                         //std::cout << "Try -h or --help" << std::endl;
    00206                         //throw ErrorClass(
    00207                         //              "There must be at least one command line argument\n  Try -h or --help");
    00208                         //delete osoptions;
    00209                         //return 1;
    00210                         getVersionInfo();
    00211                         //this is the interactive shell
    00212                         scannerActive = true;
    00213                         ossslex_init(&scanner);
    00214                         setyyextra(osoptions, scanner);
    00215                         std::string lineText;
    00216                         bool validName;
    00217                         //use a blank to separate words
    00218                         std::string wordSep = " ";
    00219                         std::string optionName = "";
    00220                         std::string optionValue = "";
    00221                         std::string::size_type indexStart;
    00222                         std::string::size_type indexEnd;
    00223                         unsigned int k;
    00224
    00225
    00226                         std::string commandArray[12] = { "solve", "send", "getJobID", "retrieve", "kill", "knock",
    00227                                         "quit", "exit",  "reset", "list", "?", "help"};
    00228
    00229
    00230                         std::string optionArray[10] = { "osil", "osrl", "osol", "mps", "nl", "dat",
    00231                                         "serviceLocation", "solver", "osplInput",  "osplOutput"};
    00232
    00233
    00234                         size_t size_of_commandArray = (sizeof commandArray)
    00235                                         / (sizeof commandArray[0]);
    00236
    00237                         size_t size_of_optionArray = (sizeof optionArray)
    00238                                         / (sizeof optionArray[0]);
    00239
    00240
    00241                         //fill in the command array into a map
    00242
    00243                         std::map<string, int> commandMap;
    00244                         //std::map<string, int>::const_iterator iter;
    00245
    00246                         for(k = 0; k < size_of_commandArray; k++){
    00247                                 commandMap[ commandArray[ k] ] = k;
    00248                         }
    00249
    00250                         //fill in the option array into a map
    00251
    00252                         std::map<string, int> optionMap;
    00253
    00254
    00255                         for(k = 0; k < size_of_optionArray; k++){
    00256                                 optionMap[ optionArray[ k] ] = k;
    00257                         }
    00258
    00259                     //for (iter=optionMap.begin(); iter != optionMap.end(); ++iter) {
    00260                     //    cout << iter->second << " " << iter->first << endl;
    00261                    //}
    00262
    00263                         std::cout << "At the prompt enter a valid command or option value pair.\n";
    00264                         std::cout << "Enter the \"solve\" command to optimize.\n";
    00265                         std::cout << "Type \"quit\" or \"exit\" to leave the application. \n";
    00266                         std::cout << "Type \"help\" or \"?\" for a list of valid options.\n\n";
    00267
    00268                         //std::cout << "Number of Options = " <<  size_of_array << std::endl;
    00269                         while (osoptions->quit != true && osoptions->exit != true) {
    00270 /*                              std::cout << "At the prompt enter a valid command or option value pair.\n";
    00271                                 std::cout << "Enter the \"solve\" command to optimize.\n";
    00272                                 std::cout << "Type \"quit/exit\" to leave the application. \n";
    00273                                 std::cout << "Type \"help\" or \"?\" for a list of valid options.\n\n";
    00274 */
    00275                                 std::cout <<  "Please enter a command, or an option followed by an option value: ";
    00276                                 getline(std::cin, lineText);
    00277                                 lineText = " " + lineText + " ";
    00278                                 //get the name of the option
    00279                                 indexStart = lineText.find_first_not_of(wordSep);
    00280                                 if (indexStart == string::npos) {
    00281                                         std::cout << std::endl;
    00282                                         std::cout << "You did not enter a valid option."
    00283                                                         << std::endl;
    00284                                 } else {
    00285                                         indexEnd = lineText.find_first_of(wordSep, indexStart + 1);
    00286                                         optionName = lineText.substr(indexStart, indexEnd
    00287                                                         - indexStart);
    00288                                         //std::cout << "Option Name = " << optionName << std::endl;
    00289
    00290                                         validName = false;
    00291                                         if( (commandMap.find(optionName) != commandMap.end() ) ||
    00292                                                         (optionMap.find(optionName) != optionMap.end() ) ){
    00293                                                 validName = true;
    00294                                         }
    00295                                         if (validName == false) {
    00296                                                 std::cout << std::endl;
    00297                                                 std::cout << "You did not enter a valid option."
    00298                                                                 << std::endl;
    00299                                         } else {
    00300
    00301                                                 // get the option value
    00302                                                 indexStart = lineText.find_first_not_of(wordSep,
    00303                                                                 indexEnd + 1);
    00304                                                 indexEnd = lineText.find_first_of(wordSep, indexStart
    00305                                                                 + 1);
    00306                                                 if (indexStart != std::string::npos && indexEnd
    00307                                                                 != std::string::npos) {
    00308                                                         optionValue = lineText.substr(indexStart, indexEnd
    00309                                                                         - indexStart);
    00310                                                 } else {
    00311                                                         optionValue = "";
    00312                                                 }
    00313
    00314                                                 //std::cout << "Option Value = " << optionValue << std::endl;
    00315
    00316                                                 try {
    00317                                                         //first we process the commands
    00318                                                         if( commandMap.find(optionName) != commandMap.end()  ){
    00319                                                                 switch (commandMap[ optionName] ){
    00320
    00321                                                                 case 0: // solve command
    00322
    00323                                                                         if(osoptions->osil == "" && osoptions->mps == "" &&  osoptions->nl == ""){
    00324                                                                                 std::cout
    00325                                                                                         << std::endl
    00326                                                                                         << "You did not specify an optimization instance!!!\n"
    00327                                                                                         << "Please enter file format option (osil, nl, or mps) \n"
    00328                                                                                         << "followed by the option value which is the file location. \n"
    00329                                                                                         << std::endl;
    00330                                                                                 //std::cout
    00331                                                                                 //      << "Please enter the path and optimization instance file name: ";
    00332                                                                                 //getline(std::cin, osoptions->osilFile);
    00333                                                                                 //osoptions->osil
    00334                                                                                 //      = fileUtil->getFileAsString(
    00335                                                                                 //                      (osoptions->osilFile).c_str());
    00336                                                                         }else{
    00337                                                                                 solve();
    00338                                                                                 if (osoptions->osrlFile != "")
    00339                                                                                         std::cout <<  "\nSolve command executed. Please see " << osoptions->osrlFile  << " for results." << std::endl;
    00340                                                                         }
    00341                                                                         break;
    00342
    00343                                                                 case 1: // send command
    00344
    00345                                                                         if(osoptions->serviceLocation == ""){
    00346                                                                                 std::cout
    00347                                                                                         << std::endl
    00348                                                                                         << "A service location is required"
    00349                                                                                         << std::endl;
    00350                                                                                 std::cout
    00351                                                                                         << "Please the URL of the remote service: ";
    00352                                                                                 getline(std::cin, osoptions->serviceLocation);
    00353                                                                         }
    00354                                                                         send();
    00355                                                                         break;
    00356
    00357
    00358                                                                 case 2: // getJobID command
    00359
    00360                                                                         if(osoptions->serviceLocation == ""){
    00361                                                                                 std::cout
    00362                                                                                         << std::endl
    00363                                                                                         << "A service location is required"
    00364                                                                                         << std::endl;
    00365                                                                                 std::cout
    00366                                                                                         << "Please the URL of the remote service: ";
    00367                                                                                 getline(std::cin, osoptions->serviceLocation);
    00368                                                                         }
    00369
    00370                                                                         getJobID();
    00371                                                                         break;
    00372
    00373
    00374                                                                 case 3: // retrieve command
    00375
    00376                                                                         if(osoptions->serviceLocation == ""){
    00377                                                                                 std::cout
    00378                                                                                         << std::endl
    00379                                                                                         << "A service location is required"
    00380                                                                                         << std::endl;
    00381                                                                                 std::cout
    00382                                                                                         << "Please the URL of the remote service: ";
    00383                                                                                 getline(std::cin, osoptions->serviceLocation);
    00384                                                                         }
    00385                                                                         if( (osoptions->osolFile == "") && (osoptions->jobID == "") ){
    00386                                                                                 std::cout
    00387                                                                                         << std::endl
    00388                                                                                         << "Cannot retrieve: no JobID and no OSoL file"
    00389                                                                                         << std::endl;
    00390                                                                         }else{
    00391                                                                                 retrieve();
    00392                                                                         }
    00393
    00394                                                                         break;
    00395
    00396                                                                 case 4: // kill command
    00397
    00398
    00399                                                                         if(osoptions->serviceLocation == ""){
    00400                                                                                 std::cout
    00401                                                                                         << std::endl
    00402                                                                                         << "A service location is required"
    00403                                                                                         << std::endl;
    00404                                                                                 std::cout
    00405                                                                                         << "Please the URL of the remote service: ";
    00406                                                                                 getline(std::cin, osoptions->serviceLocation);
    00407                                                                         }
    00408                                                                         if( (osoptions->osolFile == "") && (osoptions->jobID == "") ){
    00409                                                                                 std::cout
    00410                                                                                         << std::endl
    00411                                                                                         << "Cannot kill: no JobID and no OSoL file"
    00412                                                                                         << std::endl;
    00413                                                                         }else{
    00414                                                                                 kill();
    00415                                                                         }
    00416
    00417
    00418                                                                         break;
    00419
    00420
    00421                                                                 case 5: // knock command
    00422
    00423                                                                         //note -- can have empty OSoL for knock
    00424                                                                         //however we do need an OSpL file
    00425
    00426                                                                         if(osoptions->serviceLocation == ""){
    00427                                                                                 std::cout
    00428                                                                                         << std::endl
    00429                                                                                         << "A service location is required"
    00430                                                                                         << std::endl;
    00431                                                                                 std::cout
    00432                                                                                         << "Please the URL of the remote service: ";
    00433                                                                                 getline(std::cin, osoptions->serviceLocation);
    00434                                                                         }
    00435
    00436                                                                         if( osoptions->osplInputFile == ""){
    00437                                                                                 std::cout
    00438                                                                                         << std::endl
    00439                                                                                         << "Cannot knock -- no OSplInputFile specificed"
    00440                                                                                         << std::endl;
    00441                                                                         }else{
    00442                                                                                 knock();
    00443                                                                         }
    00444
    00445                                                                         break;
    00446
    00447
    00448                                                                 case 6: // quit command
    00449
    00450                                                                         return 0;
    00451
    00452
    00453
    00454                                                                 case 7: // exit command
    00455
    00456                                                                         return 0;
    00457
    00458
    00459
    00460                                                                 case 8: // reset command
    00461
    00462                                                                         reset_options();
    00463                                                                         std::cout << "\nAll options reset.\n";
    00464                                                                         break;
    00465
    00466
    00467
    00468                                                                 case 9: // list command
    00469
    00470                                                                         listOptions( osoptions);
    00471                                                                         break;
    00472
    00473
    00474                                                                 case 10: // ? command
    00475
    00476                                                                         std::cout << get_options() << std::endl;
    00477                                                                         break;
    00478
    00479
    00480                                                                 case 11: // help command
    00481
    00482                                                                         std::cout << get_options() << std::endl;
    00483                                                                         break;
    00484
    00485
    00486                                                                 default:
    00487                                                                         throw ErrorClass("we don't have a valid  command");
    00488
    00489
    00490                                                                 } //end switch
    00491
    00492                                                         } else { // now in the case where we require option values
    00493
    00494                                                                 if (optionValue == "") {
    00495
    00496
    00497
    00498                                                                         if(optionMap.find(optionName) != optionMap.end() ){
    00499
    00500
    00501                                                                                 switch (optionMap[ optionName] ){
    00502
    00503                                                                                 case 0: //osil
    00504                                                                                         std::cout
    00505                                                                                                 << "Please enter the name of an osil file: ";
    00506                                                                                 break;
    00507
    00508
    00509                                                                                 case 1: //osrl
    00510                                                                                         std::cout
    00511                                                                                                 << "Please enter the name of an osrl file: ";
    00512                                                                                 break;
    00513
    00514                                                                                 case 2: //osol
    00515                                                                                         std::cout
    00516                                                                                                 << "Please enter the name of an osol file: ";
    00517                                                                                 break;
    00518
    00519                                                                                 case 3: //mps
    00520                                                                                         std::cout
    00521                                                                                                 << "Please enter the name of an mps file: ";
    00522                                                                                 break;
    00523
    00524                                                                                 case 4: //nl
    00525                                                                                         std::cout
    00526                                                                                                 << "Please enter the name of an AMPL nl file: ";
    00527                                                                                 break;
    00528
    00529                                                                                 case 5: //dat
    00530                                                                                         std::cout
    00531                                                                                                 << "Please enter the name of an dat file: ";
    00532                                                                                 break;
    00533
    00534                                                                                 case 6: //service location
    00535                                                                                         std::cout
    00536                                                                                                 << "Please enter the serviceLocation: ";
    00537                                                                                 break;
    00538
    00539                                                                                 case 7: //solver
    00540                                                                                         std::cout
    00541                                                                                                 << "Please enter the name of the solver: ";
    00542                                                                                 break;
    00543
    00544                                                                                 case 8: //osplInput
    00545                                                                                         std::cout
    00546                                                                                                 << "Please enter the name of an osplInput file: ";
    00547                                                                                 break;
    00548
    00549                                                                                 case 9: //osplOutput
    00550                                                                                         std::cout
    00551                                                                                                 << "Please enter the name of an osplOutput file: ";
    00552                                                                                 break;
    00553
    00554
    00555                                                                                 }// end switch
    00556                                                                                 // now get the option value
    00557                                                                                 getline(std::cin, optionValue);
    00558                                                                         }// end if on finding an element in the optionMap
    00559
    00560                                                                 } // end if on whether or not option value is null
    00561
    00562                                                                 lineText = optionName + " "
    00563                                                                         + optionValue + " ";
    00564                                                                 osss_scan_string(lineText.c_str(),
    00565                                                                         scanner);
    00566                                                                 ossslex(scanner);
    00567                                                                 listOptions( osoptions);
    00568
    00569                                                                 if(optionMap.find(optionName) != optionMap.end() ){
    00570
    00571
    00572                                                                         switch (optionMap[ optionName] ){
    00573
    00574                                                                         case 0: //osil
    00575
    00576                                                                                 osoptions->osil
    00577                                                                                         = fileUtil->getFileAsString(
    00578                                                                                                 (osoptions->osilFile).c_str());
    00579                                                                         break;
    00580
    00581
    00582                                                                         case 1: //osrl
    00583
    00584                                                                         break;
    00585
    00586                                                                         case 2: //osol
    00587
    00588                                                                                 osoptions->osol
    00589                                                                                         = fileUtil->getFileAsString(
    00590                                                                                                 (osoptions->osolFile).c_str());
    00591                                                                         break;
    00592
    00593                                                                         case 3: //mps
    00594
    00595                                                                                 osoptions->mps
    00596                                                                                         = fileUtil->getFileAsString(
    00597                                                                                                 (osoptions->mpsFile).c_str());
    00598                                                                         break;
    00599
    00600                                                                         case 4: //nl
    00601
    00602                                                                                 osoptions->nl
    00603                                                                                         = fileUtil->getFileAsString(
    00604                                                                                                 (osoptions->nlFile).c_str());
    00605                                                                         break;
    00606
    00607                                                                         case 5: //dat
    00608
    00609                                                                                 osoptions->dat
    00610                                                                                         = fileUtil->getFileAsString(
    00611                                                                                                 (osoptions->datFile).c_str());
    00612                                                                         break;
    00613
    00614                                                                         case 6: //service location
    00615
    00616                                                                         break;
    00617
    00618                                                                         case 7: //solver
    00619
    00620                                                                                 //make solver name lower case
    00621                                                                                 for (k = 0; k
    00622                                                                                         < osoptions->solverName.length(); k++) {
    00623                                                                                         osoptions->solverName[k] = tolower(
    00624                                                                                                 osoptions->solverName[k]);
    00625                                                                                 }
    00626                                                                         break;
    00627
    00628                                                                         case 8: //osplInput
    00629
    00630                                                                                 osoptions->osplInput
    00631                                                                                         = fileUtil->getFileAsString(
    00632                                                                                                 (osoptions->osplInputFile).c_str());
    00633                                                                         break;
    00634
    00635                                                                         case 9: //osplOutput
    00636
    00637                                                                         break;
    00638
    00639
    00640
    00641                                                                         }// end switch
    00642
    00643                                                                 }// end if on finding an element in the optionMap
    00644
    00645                                                         } // end if on options that require a value
    00646
    00647                                                         std::cout << std::endl;
    00648                                                 }//end try
    00649                                                 catch (const ErrorClass& eclass) {
    00650                                                         std::cout << eclass.errormsg << std::endl;
    00651                                                 }
    00652                                         }
    00653                                 }
    00654                         }//end while loop
    00655                         ossslex_destroy(scanner);
    00656                         scannerActive = false;
    00657                         delete osoptions;
    00658                         osoptions = NULL;
    00659                         delete fileUtil;
    00660                         fileUtil = NULL;
    00661
    00662                         return 0;
    00663
    00664                 }// end of if (argC < 2)
    00665                 // make sure we do not exceed max allowed characters in command line
    00666                 i = 1;
    00667                 while (i < argC) {
    00668                         if (strlen(osss) + strlen(argV[i]) + 1 > MAXCHARS)
    00669                                 throw ErrorClass("the command line has too many characters");
    00670                         strcat(osss, argV[i]);
    00671                         strcat(osss, space);
    00672                         i++;
    00673                 }
    00674 #ifdef DEBUG_CL_INTERFACE
    00675                 cout << "Input String = " << osss << endl;
    00676 #endif
    00677                 scannerActive = true;
    00678                 ossslex_init(&scanner);
    00679                 //std::cout << "Call Text Extra" << std::endl;
    00680                 setyyextra(osoptions, scanner);
    00681                 //std::cout << "Call scan string " << std::endl;
    00682                 osss_scan_string(osss, scanner);
    00683 #ifdef DEBUG_CL_INTERFACE
    00684                 std::cout << "call ossslex" << std::endl;
    00685 #endif
    00686                 ossslex(scanner);
    00687                 ossslex_destroy(scanner);
    00688                 scannerActive = false;
    00689 #ifdef DEBUG_CL_INTERFACE
    00690                 std::cout << "done with call to ossslex" << std::endl;
    00691 #endif
    00692                 // if there is a config file, get those options
    00693                 if (osoptions->configFile != "") {
    00694                         scannerActive = true;
    00695                         ossslex_init(&scanner);
    00696                         configFileName = osoptions->configFile;
    00697 #ifdef DEBUG_CL_INTERFACE
    00698                         cout << "configFileName = " << configFileName << endl;
    00699 #endif
    00700                         std::string osolfileOptions = fileUtil->getFileAsString(
    00701                                         configFileName.c_str());
    00702 #ifdef DEBUG_CL_INTERFACE
    00703                         std::cout << "Call Text Extra" << std::endl;
    00704 #endif
    00705                         setyyextra(osoptions, scanner);
    00706 #ifdef DEBUG_CL_INTERFACE
    00707                         std::cout << "Done with call Text Extra" << std::endl;
    00708 #endif
    00709                         osss_scan_string(osolfileOptions.c_str(), scanner);
    00710                         ossslex(scanner);
    00711                         ossslex_destroy(scanner);
    00712                         scannerActive = false;
    00713                 }
    00714         } catch (const ErrorClass& eclass) {
    00715                 //cout << eclass.errormsg <<  endl;
    00716                 //cout << "try -h or --help for more information" <<  endl;
    00717
    00718                 //new stuff on April 17, 2010
    00719                 OSResult *osresult = NULL;
    00720                 OSrLWriter *osrlwriter = NULL;
    00721                 osrlwriter = new OSrLWriter();
    00722                 osresult = new OSResult();
    00723                 osresult->setGeneralMessage(eclass.errormsg);
    00724                 osresult->setGeneralStatusType("error");
    00725                 std::string osrl = osrlwriter->writeOSrL(osresult);
    00726                 if (osoptions->osrlFile != "") {
    00727                         //fileUtil->writeFileFromString(osoptions->osrlFile,  eclass.errormsg);
    00728                         fileUtil->writeFileFromString(osoptions->osrlFile, osrl);
    00729                         if (osoptions->browser != "") {
    00730                                 std::string str = osoptions->browser + "  "
    00731                                                 + osoptions->osrlFile;
    00732                                 const char *ch = &str[0];
    00733                                 std::system(ch);
    00734                         }
    00735                 } else {
    00736                         //std::cout <<  eclass.errormsg << std::endl;
    00737                         std::cout << osrl << std::endl;
    00738                 }
    00739                 //catch garbage collection
    00740                 delete osresult;
    00741                 osresult = NULL;
    00742                 delete osrlwriter;
    00743                 osrlwriter = NULL;
    00744                 // end new stuff
    00745
    00746                 if (scannerActive == true)
    00747                         ossslex_destroy(scanner);
    00748                 delete fileUtil;
    00749                 delete osoptions;
    00750                 return 1;
    00751         }
    00752         try {
    00753                 if (osoptions->invokeHelp == true) {
    00754                         std::string helpTxt = get_help();
    00755                         std::cout << std::endl << std::endl;
    00756                         std::cout << helpTxt << std::endl;
    00757                         delete osoptions;
    00758                         osoptions = NULL;
    00759                         return 0;
    00760                 }
    00761                 if (osoptions->writeVersion == true) {
    00762                         std::string writeTxt = get_version();
    00763                         std::cout << std::endl << std::endl;
    00764                         std::cout << writeTxt << std::endl;
    00765                         delete osoptions;
    00766                         osoptions = NULL;
    00767                         return 0;
    00768                 }
    00769         } catch (const ErrorClass& eclass) {
    00770                 //cout << eclass.errormsg <<  endl;
    00771                 //cout << "try -h or --help" <<  endl;
    00772
    00773
    00774                 //new stuff on April 17, 2010
    00775                 OSResult *osresult = NULL;
    00776                 OSrLWriter *osrlwriter = NULL;
    00777                 osrlwriter = new OSrLWriter();
    00778                 osresult = new OSResult();
    00779                 osresult->setGeneralMessage(eclass.errormsg);
    00780                 osresult->setGeneralStatusType("error");
    00781                 std::string osrl = osrlwriter->writeOSrL(osresult);
    00782                 if (osoptions->osrlFile != "") {
    00783                         //fileUtil->writeFileFromString(osoptions->osrlFile,  eclass.errormsg);
    00784                         fileUtil->writeFileFromString(osoptions->osrlFile, osrl);
    00785                         if (osoptions->browser != "") {
    00786                                 std::string str = osoptions->browser + "  "
    00787                                                 + osoptions->osrlFile;
    00788                                 const char *ch = &str[0];
    00789                                 std::system(ch);
    00790                         }
    00791                 } else {
    00792                         //std::cout <<  eclass.errormsg << std::endl;
    00793                         std::cout << osrl << std::endl;
    00794                 }
    00795                 //catch garbage collection
    00796                 delete osresult;
    00797                 osresult = NULL;
    00798                 delete osrlwriter;
    00799                 osrlwriter = NULL;
    00800                 // end new stuff
    00801
    00802
    00803                 delete osoptions;
    00804                 osoptions = NULL;
    00805                 delete inputFileUtil;
    00806                 inputFileUtil = NULL;
    00807                 return 1;
    00808         }
    00809
    00810 #ifdef DEBUG_CL_INTERFACE
    00811         cout << "HERE ARE THE OPTION VALUES:" << endl;
    00812         if(osoptions->configFile != "") cout << "Config file = " << osoptions->configFile << endl;
    00813         if(osoptions->osilFile != "") cout << "OSiL file = " << osoptions->osilFile << endl;
    00814         if(osoptions->osolFile != "") cout << "OSoL file = " << osoptions->osolFile << endl;
    00815         if(osoptions->osrlFile != "") cout << "OSrL file = " << osoptions->osrlFile << endl;
    00816         //if(osoptions->insListFile != "") cout << "Instruction List file = " << osoptions->insListFile << endl;
    00817         if(osoptions->osplInputFile != "") cout << "OSpL Input file = " << osoptions->osplInputFile << endl;
    00818         if(osoptions->serviceMethod != "") cout << "Service Method = " << osoptions->serviceMethod << endl;
    00819         if(osoptions->mpsFile != "") cout << "MPS File Name = " << osoptions->mpsFile << endl;
    00820         if(osoptions->nlFile != "") cout << "NL File Name = " << osoptions->nlFile << endl;
    00821         if(osoptions->gamsControlFile != "") cout << "gams Control File Name = " << osoptions->gamsControlFile << endl;
    00822         if(osoptions->browser != "") cout << "Browser Value = " << osoptions->browser << endl;
    00823         if(osoptions->solverName != "") cout << "Selected Solver = " << osoptions->solverName << endl;
    00824         if(osoptions->serviceLocation != "") cout << "Service Location = " << osoptions->serviceLocation << endl;
    00825 #endif
    00826
    00827         //convert to lower case so there is no solver name ambiguity
    00828         unsigned int k;
    00829         for (k = 0; k < osoptions->solverName.length(); k++) {
    00830                 osoptions->solverName[k] = tolower(osoptions->solverName[k]);
    00831         }
    00832
    00833         // get the data from the files
    00834         fileUtil = new FileUtil();
    00835         try {
    00836                 //if(osoptions->insListFile != "") osoptions->insList = fileUtil->getFileAsChar( (osoptions->insListFile).c_str() );
    00837                 if (osoptions->osolFile != "") {
    00838
    00839                         osoptions->osol = fileUtil->getFileAsString(
    00840                                         (osoptions->osolFile).c_str());
    00841
    00842                 }
    00843
    00844                 if (osoptions->osilFile != "") {
    00845                         //this takes precedence over what is in the OSoL file
    00846                         osoptions->osil = fileUtil->getFileAsString(
    00847                                         (osoptions->osilFile).c_str());
    00848                 }
    00849                 /*
    00850                  else{// we were not given an osil file
    00851                  // make sure we don't have a service URI in the file or are using mps or nl
    00852                  // if we have nl or mps assume a local solve
    00853                  if( (osoptions->osol != "") && (osoptions->nlFile == "") && (osoptions->gamsControlFile == "") && (osoptions->mpsFile == "") && (osoptions->serviceLocation == "")  &&  (getServiceURI( osoptions->osol) == "") )
    00854                  osoptions->osil = fileUtil->getFileAsString( getInstanceLocation( osoptions->osol).c_str()  );
    00855                  }
    00856                  */
    00857
    00858                 //if(osoptions->osplInputFile != "") osoptions->osplInput = fileUtil->getFileAsChar( (osoptions->osplInputFile).c_str()  );
    00859                 if (osoptions->osplInputFile != "")
    00860                         osoptions->osplInput = fileUtil->getFileAsString(
    00861                                         (osoptions->osplInputFile).c_str());
    00862                 //if(osoptions->osplOutputFile != "") osoptions->osplOutput = fileUtil->getFileAsChar( (osoptions->osplOutputFile).c_str() );
    00863                 if (osoptions->osplOutputFile != "")
    00864                         osoptions->osplOutput = fileUtil->getFileAsString(
    00865                                         (osoptions->osplOutputFile).c_str());
    00866         } catch (const ErrorClass& eclass) {
    00867                 //cout << eclass.errormsg <<  endl;
    00868                 //cout << "could not open file properly" << endl;
    00869                 //cout << "try -h or --help" <<  endl;
    00870
    00871
    00872                 //new stuff on April 17, 2010
    00873                 OSResult *osresult = NULL;
    00874                 OSrLWriter *osrlwriter = NULL;
    00875                 osrlwriter = new OSrLWriter();
    00876                 osresult = new OSResult();
    00877                 osresult->setGeneralMessage(eclass.errormsg);
    00878                 osresult->setGeneralStatusType("error");
    00879                 std::string osrl = osrlwriter->writeOSrL(osresult);
    00880                 if (osoptions->osrlFile != "") {
    00881                         //fileUtil->writeFileFromString(osoptions->osrlFile,  eclass.errormsg);
    00882                         fileUtil->writeFileFromString(osoptions->osrlFile, osrl);
    00883                         if (osoptions->browser != "") {
    00884                                 std::string str = osoptions->browser + "  "
    00885                                                 + osoptions->osrlFile;
    00886                                 const char *ch = &str[0];
    00887                                 std::system(ch);
    00888                         }
    00889                 } else {
    00890                         //std::cout <<  eclass.errormsg << std::endl;
    00891                         std::cout << osrl << std::endl;
    00892                 }
    00893                 //catch garbage collection
    00894                 delete osresult;
    00895                 osresult = NULL;
    00896                 delete osrlwriter;
    00897                 osrlwriter = NULL;
    00898                 // end new stuff
    00899
    00900
    00901                 delete osoptions;
    00902                 osoptions = NULL;
    00903                 delete fileUtil;
    00904                 fileUtil = NULL;
    00905                 return 1;
    00906         }
    00907         // now call the correct serviceMethod
    00908         // solve is the default
    00909         if (osoptions->serviceMethod == "")
    00910                 solve();
    00911         if ((osoptions->serviceMethod[0] == 's') && (osoptions->serviceMethod[1]
    00912                         == 'o'))
    00913                 solve();
    00914         else {
    00915                 switch (osoptions->serviceMethod[0]) {
    00916                 case 'g':
    00917                         getJobID();
    00918                         break;
    00919                 case 'r':
    00920                         retrieve();
    00921                         break;
    00922                 case 's':
    00923                         send();
    00924                         break;
    00925                 case 'k':
    00926                         if (osoptions->serviceMethod[1] == 'i')
    00927                                 kill();
    00928                         else
    00929                                 knock();
    00930                         break;
    00931                 default:
    00932
    00933                         break;
    00934                 }
    00935         }
    00936         delete osoptions;
    00937         osoptions = NULL;
    00938         delete fileUtil;
    00939         fileUtil = NULL;
    00940         return 0;
    00941 }
    00942
    00943 void solve() {
    00944         std::string osrl = "";
    00945         OSiLReader *osilreader = NULL;
    00946         OSmps2osil *mps2osil = NULL;
    00947 #ifdef COIN_HAS_ASL
    00948         OSnl2osil *nl2osil = NULL;
    00949 #endif
    00950 #ifdef COIN_HAS_GAMSUTILS
    00951         OSgams2osil *gams2osil = NULL;
    00952 #endif
    00953         OSSolverAgent* osagent = NULL;
    00954         FileUtil *fileUtil = NULL;
    00955         fileUtil = new FileUtil();
    00956         // now solve either remotely or locally
    00957         try {
    00958                 if (osoptions->serviceLocation != "") {
    00959                         // call a method here to get OSiL if we have an nl or mps file
    00960                         if (osoptions->osil == "") {
    00961                                 //we better have an nl file present or mps file or osol file
    00962                                 if (osoptions->nlFile != "") {
    00963                                         getOSiLFromNl();
    00964                                 } else {
    00965                                         if (osoptions->mpsFile != "") {
    00966                                                 getOSiLFromMps();
    00967                                         } else {
    00968                                                 if (osoptions->gamsControlFile != "") {
    00969
    00970                                                         getOSiLFromGams();
    00971                                                 } else {// send an empty osil string
    00972                                                         osoptions->osil = "";
    00973                                                 }
    00974                                         }
    00975                                 }
    00976                         }
    00977                         // place a remote call
    00978
    00979                         osagent = new OSSolverAgent(osoptions->serviceLocation);
    00980
    00981                         if (osoptions->osol == "") {// we have no osol string
    00982
    00983                                 std::ostringstream outStr;
    00984                                 outStr
    00985                                                 << "<?xml version=\"1.0\" encoding=\"UTF-8\"?> <osol xmlns=\"os.optimizationservices.org\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:schemaLocation=\"os.optimizationservices.org http://www.optimizationservices.org/schemas/";
    00986                                 outStr << OS_SCHEMA_VERSION;
    00987                                 outStr << "/OSoL.xsd\"></osol>";
    00988                                 osoptions->osol = outStr.str();
    00989                         }
    00990                         osrl = osagent->solve(osoptions->osil, osoptions->osol);
    00991                         if (osoptions->osrlFile != "") {
    00992                                 fileUtil->writeFileFromString(osoptions->osrlFile, osrl);
    00993                                 //const char *ch1 = "/Applications/Firefox.app/Contents/MacOS/firefox  ";
    00994                                 if (osoptions->browser != "") {
    00995                                         std::string str = osoptions->browser + "  "
    00996                                                         + osoptions->osrlFile;
    00997                                         const char *ch = &str[0];
    00998                                         std::system(ch);
    00999                                 }
    01000                         } else
    01001                                 cout << osrl << endl;
    01002                         delete osagent;
    01003                         osagent = NULL;
    01004
    01005                 } else {// solve locally
    01006                         if (osoptions->osil != "") {
    01007                                 osilreader = new OSiLReader();
    01008                                 osrl = buildSolver(osoptions->solverName, osoptions->osol,
    01009                                                 osilreader->readOSiL(osoptions->osil));
    01010                         } else {
    01011                                 //we better have an nl file present or mps file or osol file
    01012                                 if (osoptions->nlFile != "") {
    01013 #ifdef COIN_HAS_ASL
    01014                                         nl2osil = new OSnl2osil( osoptions->nlFile);
    01015                                         nl2osil->createOSInstance();
    01016                                         osrl = buildSolver(osoptions->solverName, osoptions->osol, nl2osil->osinstance);
    01017 #else
    01018                                         throw ErrorClass(
    01019                                                         "nlFile specified locally but ASL not present");
    01020 #endif
    01021                                 } else {
    01022                                         if (osoptions->mpsFile != "") {
    01023                                                 mps2osil = new OSmps2osil(osoptions->mpsFile);
    01024                                                 mps2osil->createOSInstance();
    01025                                                 osrl = buildSolver(osoptions->solverName,
    01026                                                                 osoptions->osol, mps2osil->osinstance);
    01027                                         } else {
    01028                                                 if (osoptions->gamsControlFile != "") {
    01029 #ifdef COIN_HAS_GAMSUTILS
    01030                                                         gams2osil = new OSgams2osil( osoptions->gamsControlFile);
    01031                                                         gams2osil->createOSInstance();
    01032                                                         osrl = buildSolver(osoptions->solverName, osoptions->osol, gams2osil->osinstance);
    01033 #else
    01034                                                         throw ErrorClass(
    01035                                                                         "a Gams Control specified locally but GAMSIP not present");
    01036 #endif
    01037
    01038                                                 } else {// need an osol file with an instanceLocation specified
    01039                                                         //if( osoptions->osol.find( "<instanceLocation") == std::string::npos){
    01040                                                         throw ErrorClass(
    01041                                                                         "Error: no osil, GAMS dat, AMPL nl, or mps file given for a local solve --- \n information in the osol file is ignored for local solves.");
    01042                                                         //}
    01043                                                 }
    01044                                         }
    01045                                 }
    01046                         }
    01047                         //delete fileUtil;
    01048                         if (osoptions->osrlFile != "") {
    01049
    01050                                 fileUtil->writeFileFromString(osoptions->osrlFile, osrl);
    01051
    01052                                 //const char *ch1 = "/Applications/Firefox.app/Contents/MacOS/firefox  ";
    01053                                 if (osoptions->browser != "") {
    01054                                         std::string str = osoptions->browser + "  "
    01055                                                         + osoptions->osrlFile;
    01056                                         const char *ch = &str[0];
    01057                                         std::system(ch);
    01058                                 }
    01059                         } else
    01060                                 cout << osrl << endl;
    01061
    01062                 }//end of local solve
    01063
    01064
    01065                 //garbage collection
    01066                 if (osilreader != NULL)
    01067                         delete osilreader;
    01068                 osilreader = NULL;
    01069                 if (mps2osil != NULL)
    01070                         delete mps2osil;
    01071                 mps2osil = NULL;
    01072 #ifdef COIN_HAS_ASL
    01073                 if(nl2osil != NULL) delete nl2osil;
    01074                 nl2osil = NULL;
    01075 #endif
    01076 #ifdef COIN_HAS_GAMSUTILS
    01077                 if(gams2osil != NULL) delete gams2osil;
    01078                 gams2osil = NULL;
    01079 #endif
    01080                 delete fileUtil;
    01081                 fileUtil = NULL;
    01082
    01083         }//end try
    01084         catch (const ErrorClass& eclass) {
    01085                 std::string osrl = "";
    01086                 OSResult *osresult = NULL;
    01087                 OSrLWriter *osrlwriter = NULL;
    01088                 //first check to see if we already have OSrL,
    01089                 //if so don't create a new osresult object
    01090                 string::size_type  pos1 = eclass.errormsg.find( "<osrl");
    01091                 if(pos1 == std::string::npos){
    01092                         osrlwriter = new OSrLWriter();
    01093                         osresult = new OSResult();
    01094                         osresult->setGeneralMessage(eclass.errormsg);
    01095                         osresult->setGeneralStatusType("error");
    01096                         osrl = osrlwriter->writeOSrL(osresult);
    01097                 }else{
    01098                         osrl = eclass.errormsg;
    01099                 }
    01100                 if (osoptions->osrlFile != "") {
    01101                         //fileUtil->writeFileFromString(osoptions->osrlFile,  eclass.errormsg);
    01102                         fileUtil->writeFileFromString(osoptions->osrlFile, osrl);
    01103                         if (osoptions->browser != "") {
    01104                                 std::string str = osoptions->browser + "  "
    01105                                                 + osoptions->osrlFile;
    01106                                 const char *ch = &str[0];
    01107                                 std::system(ch);
    01108                         }
    01109                 } else {
    01110                         //std::cout <<  eclass.errormsg << std::endl;
    01111                         std::cout << osrl << std::endl;
    01112                 }
    01113                 //catch garbage collection
    01114                 if(osresult != NULL){
    01115                         delete osresult;
    01116                         osresult = NULL;
    01117                 }
    01118                 if(osrlwriter != NULL){
    01119                         delete osrlwriter;
    01120                         osrlwriter = NULL;
    01121                 }
    01122
    01123                 //regular garbage collection
    01124                 if (osilreader != NULL)
    01125                         delete osilreader;
    01126                 osilreader = NULL;
    01127                 if (mps2osil != NULL)
    01128                         delete mps2osil;
    01129                 mps2osil = NULL;
    01130 #ifdef COIN_HAS_ASL
    01131                 if(nl2osil != NULL) delete nl2osil;
    01132                 nl2osil = NULL;
    01133 #endif
    01134 #ifdef COIN_HAS_GAMSUTILS
    01135                 if(gams2osil != NULL) delete gams2osil;
    01136                 gams2osil = NULL;
    01137 #endif
    01138                 delete fileUtil;
    01139                 fileUtil = NULL;
    01140         }//end local catch
    01141
    01142 }//end solve
    01143
    01144 void getJobID() {
    01145         OSSolverAgent* osagent = NULL;
    01146         try {
    01147                 if (osoptions->serviceLocation != "") {
    01148                         osagent = new OSSolverAgent(osoptions->serviceLocation);
    01149                         osoptions->jobID = osagent->getJobID(osoptions->osol);
    01150                         cout << osoptions->jobID << endl;
    01151                         delete osagent;
    01152                         osagent = NULL;
    01153                 } else {
    01154                         delete osagent;
    01155                         osagent = NULL;
    01156                         throw ErrorClass("please specify service location (url)");
    01157                 }
    01158         } catch (const ErrorClass& eclass) {
    01159                 FileUtil *fileUtil = NULL;
    01160                 fileUtil = new FileUtil();
    01161
    01162
    01163                 std::string osrl = "";
    01164         OSResult *osresult = NULL;
    01165                 OSrLWriter *osrlwriter = NULL;
    01166                 //first check to see if we already have OSrL,
    01167                 //if so don't create a new osresult object
    01168                 string::size_type  pos1 = eclass.errormsg.find( "<osrl");
    01169                 if(pos1 == std::string::npos){
    01170                         osrlwriter = new OSrLWriter();
    01171                         osresult = new OSResult();
    01172                         osresult->setGeneralMessage(eclass.errormsg);
    01173                         osresult->setGeneralStatusType("error");
    01174                         osrl = osrlwriter->writeOSrL(osresult);
    01175                 }else{
    01176                         osrl = eclass.errormsg;
    01177                 }
    01178
    01179
    01180                 //catch garbage collection
    01181                 if(osresult != NULL){
    01182                         delete osresult;
    01183                         osresult = NULL;
    01184                 }
    01185                 if(osrlwriter != NULL){
    01186                         delete osrlwriter;
    01187                         osrlwriter = NULL;
    01188                 }
    01189
    01190
    01191                 delete fileUtil;
    01192                 fileUtil = NULL;
    01193         }
    01194 }//end getJobID
    01195
    01196
    01197 void knock() {
    01198         std::string osplOutput = "";
    01199         OSSolverAgent* osagent = NULL;
    01200         FileUtil *fileUtil = NULL;
    01201         fileUtil = new FileUtil();
    01202         try {
    01203                 if (osoptions->serviceLocation != "") {
    01204                         osagent = new OSSolverAgent(osoptions->serviceLocation);
    01205
    01206
    01207                         if (osoptions->osol == "") {
    01208                                 // we need to construct the OSoL
    01209                                 OSOption *osOption = NULL;
    01210                                 osOption = new OSOption();
    01211                                 //set the jobID if there is one
    01212                                 if(osoptions->jobID == "") osOption->setJobID( osoptions->jobID);
    01213                                 // now read the osOption object into a string
    01214                                 OSoLWriter *osolWriter = NULL;
    01215                                 osolWriter = new OSoLWriter();
    01216                                 osoptions->osol = osolWriter->writeOSoL( osOption);
    01217                                 delete osOption;
    01218                                 osOption = NULL;
    01219                                 delete osolWriter;
    01220                                 osolWriter = NULL;
    01221                         }
    01222
    01223
    01224                         osplOutput = osagent->knock(osoptions->osplInput, osoptions->osol);
    01225                         if (osoptions->osplOutputFile != "")
    01226                                 fileUtil->writeFileFromString(osoptions->osplOutputFile,
    01227                                                 osplOutput);
    01228                         else
    01229                                 cout << osplOutput << endl;
    01230                         delete osagent;
    01231                 } else {
    01232                         delete osagent;
    01233                         throw ErrorClass("please specify service location (url)");
    01234                 }
    01235                 delete fileUtil;
    01236                 fileUtil = NULL;
    01237         } catch (const ErrorClass& eclass) {
    01238                 std::string osrl = "";
    01239         OSResult *osresult = NULL;
    01240                 OSrLWriter *osrlwriter = NULL;
    01241                 //first check to see if we already have OSrL,
    01242                 //if so don't create a new osresult object
    01243                 string::size_type  pos1 = eclass.errormsg.find( "<osrl");
    01244                 if(pos1 == std::string::npos){
    01245                         osrlwriter = new OSrLWriter();
    01246                         osresult = new OSResult();
    01247                         osresult->setGeneralMessage(eclass.errormsg);
    01248                         osresult->setGeneralStatusType("error");
    01249                         std::string osrl = osrlwriter->writeOSrL(osresult);
    01250                 }else{
    01251                         osrl = eclass.errormsg;
    01252                 }
    01253
    01254                 if(osresult != NULL){
    01255                         delete osresult;
    01256                         osresult = NULL;
    01257                 }
    01258                 if(osrlwriter != NULL){
    01259                         delete osrlwriter;
    01260                         osrlwriter = NULL;
    01261                 }
    01262
    01263                 delete fileUtil;
    01264                 fileUtil = NULL;
    01265         }
    01266 }//end knock
    01267
    01268
    01269 void send() {
    01270         bool bSend = false;
    01271         OSSolverAgent* osagent = NULL;
    01272         try {
    01273                 // call a method here to get OSiL if we have an nl or mps file
    01274                 if (osoptions->osil == "") {
    01275                         //we better have an nl file present or mps file
    01276                         if (osoptions->nlFile != "") {
    01277                                 getOSiLFromNl();
    01278                         } else {
    01279                                 if (osoptions->mpsFile != "") {
    01280                                         getOSiLFromMps();
    01281                                 } else {// send an empty osil string
    01282                                         osoptions->osil = "";
    01283                                 }
    01284                         }
    01285                 }
    01286                 if (osoptions->serviceLocation != "") {
    01287                         osagent = new OSSolverAgent(osoptions->serviceLocation);
    01288                         // check to see if there is an osol
    01289                         if (osoptions->osol == "") {
    01290                                 // we need to construct the OSoL
    01291                                 OSOption *osOption = NULL;
    01292                                 osOption = new OSOption();
    01293                                 // get a jobId if necessary
    01294                                 if(osoptions->jobID == "") osoptions->jobID = osagent->getJobID("");
    01295                                 //set the jobID
    01296
    01297                                 osOption->setJobID( osoptions->jobID);
    01298                                 // now read the osOption object into a string
    01299                                 OSoLWriter *osolWriter = NULL;
    01300                                 osolWriter = new OSoLWriter();
    01301                                 osoptions->osol = osolWriter->writeOSoL( osOption);
    01302                                 delete osOption;
    01303                                 osOption = NULL;
    01304                                 delete osolWriter;
    01305                                 osolWriter = NULL;
    01306                         }
    01307                         bSend = osagent->send(osoptions->osil, osoptions->osol);
    01308                         std::cout << "Result of send: " << bSend << std::endl;
    01309                         delete osagent;
    01310                 } else {
    01311                         delete osagent;
    01312                         throw ErrorClass("please specify service location (url)");
    01313                 }
    01314         } catch (const ErrorClass& eclass) {
    01315                 std::string osrl = "";
    01316                 FileUtil *fileUtil = NULL;
    01317                 fileUtil = new FileUtil();
    01318                 OSResult *osresult = NULL;
    01319                 OSrLWriter *osrlwriter = NULL;
    01320                 //first check to see if we already have OSrL,
    01321                 //if so don't create a new osresult object
    01322                 string::size_type  pos1 = eclass.errormsg.find( "<osrl");
    01323                 if(pos1 == std::string::npos){
    01324                         osrlwriter = new OSrLWriter();
    01325                         osresult = new OSResult();
    01326                         osresult->setGeneralMessage(eclass.errormsg);
    01327                         osresult->setGeneralStatusType("error");
    01328                         osrl = osrlwriter->writeOSrL(osresult);
    01329                 }else{
    01330                         osrl = eclass.errormsg;
    01331                 }
    01332
    01333
    01334                 if (osoptions->osrlFile != "")
    01335                         fileUtil->writeFileFromString(osoptions->osrlFile, osrl);
    01336                 else
    01337                         cout << osrl << endl;
    01338
    01339                 if(osresult != NULL){
    01340                         delete osresult;
    01341                         osresult = NULL;
    01342                 }
    01343                 if(osrlwriter != NULL){
    01344                         delete osrlwriter;
    01345                         osrlwriter = NULL;
    01346                 }
    01347                 delete fileUtil;
    01348                 fileUtil = NULL;
    01349         }
    01350 }//end send
    01351
    01352 void retrieve() {
    01353         FileUtil *fileUtil = NULL;
    01354         fileUtil = new FileUtil();
    01355         std::string osrl = "";
    01356         OSSolverAgent* osagent = NULL;
    01357         try {
    01358                 if (osoptions->serviceLocation != "") {
    01359                         osagent = new OSSolverAgent(osoptions->serviceLocation);
    01360
    01361
    01362                         if (osoptions->osol == "") {
    01363                                 // we need to construct the OSoL
    01364                                 OSOption *osOption = NULL;
    01365                                 osOption = new OSOption();
    01366                                 // get a jobId if necessary
    01367                                 if(osoptions->jobID == "")throw ErrorClass("there is no JobID");
    01368                                 //set the jobID
    01369                                 osOption->setJobID( osoptions->jobID);
    01370                                 // now read the osOption object into a string
    01371                                 OSoLWriter *osolWriter = NULL;
    01372                                 osolWriter = new OSoLWriter();
    01373                                 osoptions->osol = osolWriter->writeOSoL( osOption);
    01374                                 delete osOption;
    01375                                 osOption = NULL;
    01376                                 delete osolWriter;
    01377                                 osolWriter = NULL;
    01378                         }
    01379
    01380                         osrl = osagent->retrieve(osoptions->osol);
    01381
    01382                         if (osoptions->osrlFile != "") {
    01383                                 fileUtil->writeFileFromString(osoptions->osrlFile, osrl);
    01384                                 if (osoptions->browser != "") {
    01385                                         std::string str = osoptions->browser + "  "
    01386                                                         + osoptions->osrlFile;
    01387                                         const char *ch = &str[0];
    01388                                         std::system(ch);
    01389                                 }
    01390                         } else
    01391                                 cout << osrl << endl;
    01392                         delete osagent;
    01393                         osagent = NULL;
    01394                 } else {
    01395                         delete osagent;
    01396                         osagent = NULL;
    01397                         throw ErrorClass("please specify service location (url)");
    01398                 }
    01399                 delete fileUtil;
    01400                 fileUtil = NULL;
    01401         } catch (const ErrorClass& eclass) {
    01402
    01403                 std::string osrl = "";
    01404         OSResult *osresult = NULL;
    01405                 OSrLWriter *osrlwriter = NULL;
    01406                 //first check to see if we already have OSrL,
    01407                 //if so don't create a new osresult object
    01408                 string::size_type  pos1 = eclass.errormsg.find( "<osrl");
    01409                 if(pos1 == std::string::npos){
    01410                         osrlwriter = new OSrLWriter();
    01411                         osresult = new OSResult();
    01412                         osresult->setGeneralMessage(eclass.errormsg);
    01413                         osresult->setGeneralStatusType("error");
    01414                         osrl = osrlwriter->writeOSrL(osresult);
    01415                 }else{
    01416                         osrl = eclass.errormsg;
    01417                 }
    01418
    01419                 if(osresult != NULL){
    01420                         delete osresult;
    01421                         osresult = NULL;
    01422                 }
    01423                 if(osrlwriter != NULL){
    01424                         delete osrlwriter;
    01425                         osrlwriter = NULL;
    01426                 }
    01427
    01428
    01429                 delete fileUtil;
    01430                 fileUtil = NULL;
    01431         }
    01432 }//end retrieve
    01433
    01434 void kill() {
    01435         FileUtil *fileUtil = NULL;
    01436         fileUtil = new FileUtil();
    01437         std::string osplOutput = "";
    01438         OSSolverAgent* osagent = NULL;
    01439         try {
    01440                 if (osoptions->serviceLocation != "") {
    01441                         osagent = new OSSolverAgent(osoptions->serviceLocation);
    01442
    01443
    01444                         if (osoptions->osol == "") {
    01445                                 // we need to construct the OSoL
    01446                                 OSOption *osOption = NULL;
    01447                                 osOption = new OSOption();
    01448                                 // get a jobId if necessary
    01449                                 if(osoptions->jobID == "")throw ErrorClass("there is no JobID");
    01450                                 //set the jobID
    01451                                 osOption->setJobID( osoptions->jobID);
    01452                                 // now read the osOption object into a string
    01453                                 OSoLWriter *osolWriter = NULL;
    01454                                 osolWriter = new OSoLWriter();
    01455                                 osoptions->osol = osolWriter->writeOSoL( osOption);
    01456                                 delete osOption;
    01457                                 osOption = NULL;
    01458                                 delete osolWriter;
    01459                                 osolWriter = NULL;
    01460                         }
    01461
    01462                         osplOutput = osagent->kill(osoptions->osol);
    01463
    01464                         if (osoptions->osplOutputFile != "")
    01465                                 fileUtil->writeFileFromString(osoptions->osplOutputFile,
    01466                                                 osplOutput);
    01467                         else
    01468                                 cout << osplOutput << endl;
    01469                         delete osagent;
    01470                         osagent = NULL;
    01471                 } else {
    01472                         delete osagent;
    01473                         osagent = NULL;
    01474                         throw ErrorClass("please specify service location (url)");
    01475                 }
    01476                 delete fileUtil;
    01477                 fileUtil = NULL;
    01478         } catch (const ErrorClass& eclass) {
    01479                 std::string osrl = "";
    01480         OSResult *osresult = NULL;
    01481                 OSrLWriter *osrlwriter = NULL;
    01482                 //first check to see if we already have OSrL,
    01483                 //if so don't create a new osresult object
    01484                 string::size_type  pos1 = eclass.errormsg.find( "<osrl");
    01485                 if(pos1 == std::string::npos){
    01486                         osrlwriter = new OSrLWriter();
    01487                         osresult = new OSResult();
    01488                         osresult->setGeneralMessage(eclass.errormsg);
    01489                         osresult->setGeneralStatusType("error");
    01490                         osrl = osrlwriter->writeOSrL(osresult);
    01491                 }else{
    01492                         osrl = eclass.errormsg;
    01493                 }
    01494
    01495
    01496                 if(osresult != NULL){
    01497                         delete osresult;
    01498                         osresult = NULL;
    01499                 }
    01500                 if(osrlwriter != NULL){
    01501                         delete osrlwriter;
    01502                         osrlwriter = NULL;
    01503                 }
    01504
    01505
    01506                 delete fileUtil;
    01507                 fileUtil = NULL;
    01508         }
    01509 }//end kill
    01510
    01511 void getOSiLFromNl() {
    01512         try {
    01513 #ifdef COIN_HAS_ASL
    01514                 OSnl2osil *nl2osil = NULL;
    01515                 nl2osil = new OSnl2osil( osoptions->nlFile);
    01516                 nl2osil->createOSInstance();
    01517                 OSiLWriter *osilwriter = NULL;
    01518                 osilwriter = new OSiLWriter();
    01519                 std::string osil;
    01520                 osil = osilwriter->writeOSiL( nl2osil->osinstance);
    01521                 osoptions->osil = osil;
    01522                 delete nl2osil;
    01523                 nl2osil = NULL;
    01524                 delete osilwriter;
    01525                 osilwriter = NULL;
    01526 #else
    01527                 throw ErrorClass(
    01528                                 "trying to convert nl to osil without AMPL ASL configured");
    01529 #endif
    01530         } catch (const ErrorClass& eclass) {
    01531                 std::cout << eclass.errormsg << std::endl;
    01532                 throw ErrorClass(eclass.errormsg);
    01533         }
    01534 }//getOSiLFromNl
    01535
    01536
    01537 void getOSiLFromGams() {
    01538         try {
    01539 #ifdef COIN_HAS_GAMSIO
    01540                 OSgams2osil *gams2osil = NULL;
    01541                 gams2osil = new OSgams2osil( osoptions->gamsControlFile);
    01542                 gams2osil->createOSInstance();
    01543                 OSiLWriter *osilwriter = NULL;
    01544                 osilwriter = new OSiLWriter();
    01545                 std::string osil;
    01546                 osil = osilwriter->writeOSiL( gams2osil->osinstance);
    01547                 osoptions->osil = osil;
    01548                 delete gams2osil;
    01549                 gams2osil = NULL;
    01550                 delete osilwriter;
    01551                 osilwriter = NULL;
    01552 #else
    01553                 throw ErrorClass(
    01554                                 "trying to convert Gams control file to osil without GAMSUTILS configured");
    01555 #endif
    01556         } catch (const ErrorClass& eclass) {
    01557                 std::cout << eclass.errormsg << std::endl;
    01558                 throw ErrorClass(eclass.errormsg);
    01559         }
    01560 }//getOSiLFromGams
    01561
    01562
    01563 void getOSiLFromMps() {
    01564         try {
    01565                 OSmps2osil *mps2osil = NULL;
    01566                 mps2osil = new OSmps2osil(osoptions->mpsFile);
    01567                 mps2osil->createOSInstance();
    01568                 OSiLWriter *osilwriter = NULL;
    01569                 osilwriter = new OSiLWriter();
    01570                 std::string osil;
    01571                 osil = osilwriter->writeOSiL(mps2osil->osinstance);
    01572                 osoptions->osil = osil;
    01573                 delete mps2osil;
    01574                 mps2osil = NULL;
    01575                 delete osilwriter;
    01576                 osilwriter = NULL;
    01577         } catch (const ErrorClass& eclass) {
    01578                 std::cout << eclass.errormsg << std::endl;
    01579                 throw ErrorClass(eclass.errormsg);
    01580         }
    01581
    01582 }//getOSiLFromMps
    01583
    01584 //string getServiceURI( std::string osol){
    01585 //      if(osol == "") return osol;
    01586 //      string::size_type pos2;
    01587 //      string::size_type  pos1 = osol.find( "<serviceURI");
    01588 //      if(pos1 != std::string::npos){
    01589 //              // get the end of the serviceURI start tag
    01590 //              pos1 = osol.find(">", pos1 + 1);
    01591 //              if(pos1 != std::string::npos){
    01592 //                      // get the start of serviceURI end tag
    01593 //                      pos2 = osol.find( "</serviceURI", pos1 + 1);
    01594 //                      if( pos2 != std::string::npos){
    01595 //                              // get the substring
    01596 //                              return osol.substr( pos1 + 1, pos2 - pos1 - 1);
    01597 //                      }
    01598 //                      else return "";
    01599 //              }
    01600 //              else return "";
    01601 //      }
    01602 //      else return "";
    01603 //}//getServiceURI
    01604
    01605 //string getInstanceLocation( std::string osol){
    01606 //      if(osol == "") return osol;
    01607 //      string::size_type pos2;
    01608 //      string::size_type pos1 = osol.find( "<instanceLocation");
    01609 //      if(pos1 != std::string::npos){
    01610 //              // get the end of the instanceLocation start tag
    01611 //              pos1 = osol.find(">", pos1 + 1);
    01612 //              if(pos1 != std::string::npos){
    01613 //                      // get the start of instanceLocation end tag
    01614 //                      pos2 = osol.find( "</instanceLocation", pos1 + 1);
    01615 //                      if( pos2 != std::string::npos){
    01616 //                              // get the substring
    01617 //                              return osol.substr( pos1 + 1, pos2 - pos1 - 1);
    01618 //                      }
    01619 //                      else return "";
    01620 //              }
    01621 //              else return "";
    01622 //      }
    01623 //      else return "";
    01624 //}//getInstanceLocation
    01625
    01626
    01627 //std::string getSolverName( std::string osol){
    01628 //#ifdef DEBUG_CL_INTERFACE
    01629 //      std::cout << "inside getSolverName" << std::endl;
    01630 //      std::cout <<  osol << std::endl;
    01631 //      std::cout << "done with osol" << std::endl;
    01632 //#endif
    01633 //      OSOption *osoption = NULL;
    01634 //      OSoLReader *osolreader = NULL;
    01635 //      osolreader = new OSoLReader();
    01636 //
    01637 //      osoption = osolreader->readOSoL( osol);
    01638 //#ifdef DEBUG_CL_INTERFACE
    01639 //      std::cout <<  "invoke getSolverToInvoke" << std::endl;
    01640 //#endif
    01641 //      std::string optionstring = osoption->getSolverToInvoke();
    01642 //#ifdef DEBUG_CL_INTERFACE
    01643 //      std::cout <<  "done with invoke getSolverToInvoke" << std::endl;
    01644 //#endif
    01646 //      delete osolreader;
    01647 //      return optionstring;
    01648 //      /*
    01649 //      if(osol == "") return osol;
    01650 //      string::size_type pos2;
    01651 //      string::size_type pos1 = osol.find( "solverToInvoke");
    01652 //      if(pos1 != std::string::npos){
    01653 //              // get the end of the instanceLocation start tag
    01654 //              pos1 = osol.find(">", pos1 + 1);
    01655 //              if(pos1 != std::string::npos){
    01656 //                      // get the start of instanceLocation end tag
    01657 //                      pos2 = osol.find( "</solverToInvoke", pos1 + 1);
    01658 //                      if( pos2 != std::string::npos){
    01659 //                              // get the substring
    01660 //                              return osol.substr( pos1 + 1, pos2 - pos1 - 1);
    01661 //                      }
    01662 //                      else return "";
    01663 //              }
    01664 //              else return "";
    01665 //      }
    01666 //      else return "";
    01667 //      */
    01668 //}//getSolverName
    01669
    01670
    01671 //std::string setSolverName( std::string osol, std::string solverName){
    01672 //#ifdef DEBUG_CL_INTERFACE
    01673 //      std::cout << "inside setSolverName" << std::endl;
    01674 //#endif
    01675 //      OSOption *osoption = NULL;
    01676 //      OSoLReader *osolreader = NULL;
    01677 //      osolreader = new OSoLReader();
    01678 //      osoption = osolreader->readOSoL( osol);
    01680 //      osoption->setSolverToInvoke( solverName);
    01683 //      OSoLWriter *osolwriter = NULL;
    01684 //      osolwriter = new OSoLWriter();
    01685 //      std::string newOSoL = osolwriter->writeOSoL( osoption);
    01689 //      delete osolreader;
    01690 //      delete osolwriter;
    01691 //      return newOSoL;
    01692 //}//setSolverName
    01693
    01694 std::string get_help() {
    01695
    01696         std::ostringstream helpMsg;
    01697
    01698         helpMsg << "************************* HELP *************************"
    01699                         << endl << endl;
    01700         helpMsg
    01701                         << "In this HELP file we assume that the solve service method is used and "
    01702                         << endl;
    01703         helpMsg
    01704                         << "that we are solving problems locally, that is the solver is on the "
    01705                         << endl;
    01706         helpMsg
    01707                         << "machine running this OSSolverService.  See Section 10.3 of the User\'s  "
    01708                         << endl;
    01709         helpMsg
    01710                         << "Manual for other service methods or calling a server remotely. "
    01711                         << endl;
    01712         helpMsg << "The OSSolverService takes the parameters listed below.  "
    01713                         << endl;
    01714         helpMsg
    01715                         << "The order of the parameters is irrelevant.  Not all the parameters  "
    01716                         << endl;
    01717         helpMsg << "are required.  However, the location of an instance file is  "
    01718                         << endl;
    01719         helpMsg
    01720                         << "required when using the solve service method. The location of the "
    01721                         << endl;
    01722         helpMsg << "instance file is specified using the osil option. " << endl;
    01723
    01724         helpMsg << endl;
    01725
    01726         helpMsg
    01727                         << "-osil xxx.osil this is the name of the file that contains the  "
    01728                         << endl;
    01729         helpMsg << "optimization instance in OSiL format.  This option may be  "
    01730                         << endl;
    01731         helpMsg << "specified in the OSoL solver options file. " << endl;
    01732
    01733         helpMsg << endl;
    01734
    01735         helpMsg
    01736                         << "-osol xxx.osol  this is the name of the file that contains the solver options.   "
    01737                         << endl;
    01738         helpMsg << "It is not necessary to specify this option. " << endl;
    01739
    01740         helpMsg << endl;
    01741
    01742         helpMsg
    01743                         << "-osrl xxx.osrl  this is the name of the file to which the solver solution is written.  "
    01744                         << endl;
    01745         helpMsg
    01746                         << "It is not necessary to specify this option. If this option is not specified,  "
    01747                         << endl;
    01748         helpMsg << "the result will be printed to standard out.  " << endl;
    01749
    01750         helpMsg << endl;
    01751
    01752         helpMsg
    01753                         << "-osplInput xxx.ospl  this is the name of an input file in the OS Process"
    01754                         << endl;
    01755         helpMsg << " Language (OSpL), this is used as input  to the knock method."
    01756                         << endl;
    01757
    01758         helpMsg << endl;
    01759
    01760         helpMsg
    01761                         << "-osplOutput xxx.ospl this is the name of an output file in the  OS Process"
    01762                         << endl;
    01763         helpMsg
    01764                         << "Language (OSpL), this the output string from the knock and kill methods."
    01765                         << endl;
    01766
    01767         helpMsg << endl;
    01768
    01769         helpMsg << "-serviceLocation url is the URL of the solver service.  "
    01770                         << endl;
    01771         helpMsg
    01772                         << "This is not required, and if not specified it is assumed that   "
    01773                         << endl;
    01774         helpMsg << "the problem is solved locally.  " << endl;
    01775
    01776         helpMsg << endl;
    01777
    01778         helpMsg
    01779                         << "-serviceMethod  methodName this is the method on the solver service to be invoked.  "
    01780                         << endl;
    01781         helpMsg
    01782                         << "The options are  solve,  send,  kill,  knock,  getJobID, and retrieve.   "
    01783                         << endl;
    01784         helpMsg
    01785                         << "This option is not required, and the default value is  solve.  "
    01786                         << endl;
    01787
    01788         helpMsg << endl;
    01789
    01790         helpMsg
    01791                         << "-mps  xxx.mps  this is the name of the mps file if the problem instance  "
    01792                         << endl;
    01793         helpMsg
    01794                         << "is in mps format. The default file format is OSiL so this option is not required.  "
    01795                         << endl;
    01796
    01797         helpMsg << endl;
    01798
    01799         helpMsg
    01800                         << "-nl  xxx.nl  this is the name of the AMPL nl file if the problem  "
    01801                         << endl;
    01802         helpMsg
    01803                         << "instance is in AMPL nl  format. The default file format is OSiL  "
    01804                         << endl;
    01805         helpMsg << "so this option is not required.  " << endl;
    01806
    01807         helpMsg << endl;
    01808
    01809         helpMsg
    01810                         << "-solver  solverName  Possible values for default OS installation  "
    01811                         << endl;
    01812         helpMsg
    01813                         << "are  bonmin(COIN-OR Bonmin), couenne (COIN-OR Couenne), clp (COIN-OR Clp),"
    01814                         << endl;
    01815         helpMsg << "cbc (COIN-OR Cbc), dylp (COIN-OR DyLP), ipopt (COIN-OR Ipopt),"
    01816                         << endl;
    01817         helpMsg << "and symphony (COIN-OR SYMPHONY). Other solvers supported"
    01818                         << endl;
    01819         helpMsg
    01820                         << "(if the necessary libraries are present) are cplex (Cplex through COIN-OR Osi),"
    01821                         << endl;
    01822         helpMsg
    01823                         << "glpk (glpk through COIN-OR Osi), knitro (Knitro), and lindo (LINDO)."
    01824                         << endl;
    01825         helpMsg << "If no value is specified for this parameter," << endl;
    01826         helpMsg << "then cbc is the default value of this parameter." << endl;
    01827
    01828         helpMsg << endl;
    01829
    01830         helpMsg
    01831                         << "-browser  browserName this paramater is a path to the browser on the  "
    01832                         << endl;
    01833         helpMsg
    01834                         << "local machine. If this optional parameter is specified then the  "
    01835                         << endl;
    01836         helpMsg << "solver result in OSrL format is transformed using XSLT into  "
    01837                         << endl;
    01838         helpMsg << "HTML and displayed in the browser.  " << endl;
    01839
    01840         helpMsg << endl;
    01841
    01842         helpMsg
    01843                         << "-config pathToConfigureFile this parameter specifies a path on  "
    01844                         << endl;
    01845         helpMsg
    01846                         << "the local machine to a text file containing values for the input parameters.  "
    01847                         << endl;
    01848         helpMsg
    01849                         << "This is convenient for the user not wishing to constantly retype parameter values.  "
    01850                         << endl;
    01851         helpMsg
    01852                         << "This configure file can contain values for all of the other parameters. "
    01853                         << endl;
    01854
    01855         helpMsg << endl;
    01856
    01857         helpMsg << "--version or -v get the current version of this executable  "
    01858                         << endl;
    01859
    01860         helpMsg << endl;
    01861
    01862         helpMsg << "--help or -h  to get this help file " << endl;
    01863
    01864         helpMsg << endl;
    01865
    01866         helpMsg
    01867                         << "Note: If you specify a configure file by using the -config option, you can  "
    01868                         << endl;
    01869         helpMsg
    01870                         << "override the values of the options in the configure file by putting them in   "
    01871                         << endl;
    01872         helpMsg << "at the command line. " << endl << endl;
    01873
    01874         helpMsg
    01875                         << "See the OS User\' Manual: http://www.coin-or.org/OS/doc/osUsersManual_2.0.pdf"
    01876                         << endl;
    01877         helpMsg << "for more detail on how to use the OS project. " << endl;
    01878
    01879         helpMsg << endl;
    01880         helpMsg << "********************************************************"
    01881                         << endl << endl;
    01882
    01883         return helpMsg.str();
    01884 }// get help
    01885
    01886
    01887 std::string get_version() {
    01888
    01889         std::ostringstream versionMsg;
    01890         versionMsg << "In order to find the version of this project " << endl;
    01891         versionMsg << "connect to the directory where you downloaded " << endl;
    01892         versionMsg << "and do: " << endl;
    01893         versionMsg << "svn info " << endl;
    01894
    01895         return versionMsg.str();
    01896 }// get version
    01897
    01898
    01899 std::string buildSolver(std::string solverName, std::string osol,
    01900                 OSInstance *osinstance) {
    01901         DefaultSolver *solverType = NULL;
    01902         //std::cout << "SOLVER NAME = " << solverName << std::endl;
    01903         try {
    01904                 if (solverName == "") {// must determine the default solver
    01905                         if (osinstance == NULL)
    01906                                 throw ErrorClass(
    01907                                                 "there was a NULL instance sent to buildSolver");
    01908                         //see if we have an integer program
    01909                         if (osinstance->getNumberOfIntegerVariables()
    01910                                         + osinstance->getNumberOfBinaryVariables() > 0) {//we have an integer program
    01911                                 if ((osinstance->getNumberOfNonlinearExpressions() > 0)
    01912                                                 || (osinstance->getNumberOfQuadraticTerms() > 0)) { // we are nonlinear and integer
    01913                                         solverName = "bonmin";
    01914                                 } else {//we are linear integer
    01915                                         solverName = "cbc";
    01916                                 }
    01917                         } else {// we have a continuous problem
    01918                                 if ((osinstance->getNumberOfNonlinearExpressions() > 0)
    01919                                                 || (osinstance->getNumberOfQuadraticTerms() > 0)) { // we are nonlinear and continuous
    01920                                         solverName = "ipopt";
    01921                                 } else {//we have linear program
    01922                                         solverName = "clp";
    01923                                 }
    01924                         }
    01925                 }//end of if on solverName
    01926
    01927                 //now build the solver through its constructor
    01928
    01929                 //std::cout << "SOLVER NAME =  " << solverName << std::endl;
    01930
    01931                 if (solverName.find("ipopt") != std::string::npos) {
    01932                         // we are requesting the Ipopt solver
    01933                         bool bIpoptIsPresent = false;
    01934 #ifdef COIN_HAS_IPOPT
    01935                         bIpoptIsPresent = true;
    01936                         solverType = new IpoptSolver();
    01937 #endif
    01938                         if (bIpoptIsPresent == false)
    01939                                 throw ErrorClass("the Ipopt solver requested is not present");
    01940                 } else {
    01941                         if (solverName.find("lindo") != std::string::npos) {
    01942                                 // we are requesting the Lindo solver
    01943                                 bool bLindoIsPresent = false;
    01944 #ifdef COIN_HAS_LINDO
    01945                                 bLindoIsPresent = true;
    01946                                 std::cout << "calling the LINDO Solver " << std::endl;
    01947                                 solverType = new LindoSolver();
    01948                                 std::cout << "DONE calling the LINDO Solver " << std::endl;
    01949 #endif
    01950                                 if (bLindoIsPresent == false)
    01951                                         throw ErrorClass(
    01952                                                         "the Lindo solver requested is not present");
    01953                         } else {
    01954                                 if (solverName.find("clp") != std::string::npos) {
    01955                                         //std::cout << "NEWING SOLVER TYPE " << std::endl;
    01956                                         solverType = new CoinSolver();
    01957                                         //std::cout << "END NEWING SOLVER TYPE " << std::endl;
    01958                                         solverType->sSolverName = "clp";
    01959                                 } else {
    01960                                         if (solverName.find("cplex") != std::string::npos) {
    01961                                                 bool bCplexIsPresent = false;
    01962 #ifdef COIN_HAS_CPX
    01963                                                 bCplexIsPresent = true;
    01964                                                 solverType = new CoinSolver();
    01965                                                 solverType->sSolverName = "cplex";
    01966 #endif
    01967                                                 if (bCplexIsPresent == false)
    01968                                                         throw ErrorClass(
    01969                                                                         "the Cplex solver requested is not present");
    01970                                         } else {
    01971                                                 if (solverName.find("glpk") != std::string::npos) {
    01972                                                         bool bGlpkIsPresent = false;
    01973 #ifdef COIN_HAS_GLPK
    01974                                                         bGlpkIsPresent = true;
    01975                                                         solverType = new CoinSolver();
    01976                                                         solverType->sSolverName = "glpk";
    01977 #endif
    01978                                                         if (bGlpkIsPresent == false)
    01979                                                                 throw ErrorClass(
    01980                                                                                 "the GLPK solver requested is not present");
    01981                                                 } else {
    01982                                                         if (solverName.find("dylp") != std::string::npos) {
    01983                                                                 bool bDyLPIsPresent = false;
    01984 #ifdef COIN_HAS_DYLP
    01985                                                                 bDyLPIsPresent = true;
    01986                                                                 solverType = new CoinSolver();
    01987                                                                 solverType->sSolverName = "dylp";
    01988                                                                 bDyLPIsPresent = true;
    01989 #endif
    01990                                                                 if (bDyLPIsPresent == false)
    01991                                                                         throw ErrorClass(
    01992                                                                                         "the DyLP solver requested is not present");
    01993                                                         } else {
    01994                                                                 if (solverName.find("symphony")
    01995                                                                                 != std::string::npos) {
    01996                                                                         bool bSymphonyIsPresent = false;
    01997 #ifdef COIN_HAS_SYMPHONY
    01998                                                                         bSymphonyIsPresent = true;
    01999                                                                         solverType = new CoinSolver();
    02000                                                                         solverType->sSolverName = "symphony";
    02001 #endif
    02002                                                                         if (bSymphonyIsPresent == false)
    02003                                                                                 throw ErrorClass(
    02004                                                                                                 "the SYMPHONY solver requested is not present");
    02005                                                                 } else {
    02006                                                                         if (solverName.find("knitro")
    02007                                                                                         != std::string::npos) {
    02008                                                                                 bool bKnitroIsPresent = false;
    02009 #ifdef COIN_HAS_KNITRO
    02010                                                                                 bKnitroIsPresent = true;
    02011                                                                                 std::cout << "calling the KNITRO Solver " << std::endl;
    02012                                                                                 solverType = new KnitroSolver();
    02013                                                                                 std::cout << "DONE calling the KNITRO Solver " << std::endl;
    02014 #endif
    02015                                                                                 if (bKnitroIsPresent == false)
    02016                                                                                         throw ErrorClass(
    02017                                                                                                         "the Knitro solver requested is not present");
    02018                                                                         } else {
    02019                                                                                 if (solverName.find("vol")
    02020                                                                                                 != std::string::npos) {
    02021                                                                                         bool bVolIsPresent = false;
    02022 #ifdef COIN_HAS_VOL
    02023                                                                                         bVolIsPresent = true;
    02024                                                                                         solverType = new CoinSolver();
    02025                                                                                         solverType->sSolverName = "vol";
    02026 #endif
    02027                                                                                         if (bVolIsPresent == false)
    02028                                                                                                 throw ErrorClass(
    02029                                                                                                                 "the Vol solver requested is not present");
    02030                                                                                 } else {
    02031                                                                                         if (solverName.find("bonmin")
    02032                                                                                                         != std::string::npos) {
    02033                                                                                                 // we are requesting the Bonmin solver
    02034                                                                                                 bool bBonminIsPresent = false;
    02035 #ifdef COIN_HAS_BONMIN
    02036                                                                                                 bBonminIsPresent = true;
    02037                                                                                                 solverType = new BonminSolver();
    02038 #endif
    02039                                                                                                 if (bBonminIsPresent == false)
    02040                                                                                                         throw ErrorClass(
    02041                                                                                                                         "the Bonmin solver requested is not present");
    02042                                                                                         } else {
    02043                                                                                                 if (solverName.find("couenne")
    02044                                                                                                                 != std::string::npos) {
    02045                                                                                                         // we are requesting the Couenne solver
    02046                                                                                                         bool bCouenneIsPresent =
    02047                                                                                                                         false;
    02048 #ifdef COIN_HAS_COUENNE
    02049                                                                                                         bCouenneIsPresent = true;
    02050                                                                                                         solverType = new CouenneSolver();
    02051 #endif
    02052                                                                                                         if (bCouenneIsPresent
    02053                                                                                                                         == false)
    02054                                                                                                                 throw ErrorClass(
    02055                                                                                                                                 "the Couenne solver requested is not present");
    02056                                                                                                 } else { //cbc is the default
    02057                                                                                                         solverType
    02058                                                                                                                         = new CoinSolver();
    02059                                                                                                         solverType->sSolverName
    02060                                                                                                                         = "cbc";
    02061                                                                                                 }
    02062                                                                                         }
    02063                                                                                 }
    02064                                                                         }
    02065                                                                 }
    02066                                                         }
    02067                                                 }
    02068                                         }
    02069                                 }
    02070                         }
    02071                 }
    02072
    02073                 //std::cout << "SET SOLVER INSTANCE " << std::endl;
    02074                 solverType->osinstance = osinstance;
    02075                 solverType->osol = osol;
    02076                 solverType->buildSolverInstance();
    02077                 solverType->setSolverOptions();
    02078                 solverType->solve();
    02079                 std::string resultString = solverType->osrl;
    02080                 if (solverType != NULL)
    02081                         delete solverType;
    02082                 solverType = NULL;
    02083                 return resultString;
    02084
    02085         } catch (const ErrorClass& eclass) {
    02086                 throw eclass;
    02087         }
    02088
    02089 }//buildSolver
    02090
    02091
    02092 void reset_options()
    02093 {
    02094         osoptions->configFile = "";
    02095         osoptions->osilFile = "";
    02096         osoptions->osil = "";
    02097         osoptions->osolFile = "";
    02098         osoptions->osol = "";
    02099         osoptions->osrlFile = "";
    02100         osoptions->osrl = "";
    02101         //osoptions->insListFile = "";
    02102         osoptions->insList = "";
    02103         osoptions->serviceLocation = "";
    02104         osoptions->serviceMethod = "";
    02105         osoptions->osplInputFile = "";
    02106         osoptions->osplOutputFile = "";
    02107         osoptions->osplInput = "";
    02108         osoptions->osplOutput = "";
    02109         osoptions->mpsFile = "";
    02110         osoptions->mps = "";
    02111         osoptions->nlFile = "";
    02112         osoptions->nl = "";
    02113         osoptions->gamsControlFile = "";
    02114         osoptions->solverName = "";
    02115         osoptions->browser = "";
    02116         osoptions->jobID = "";
    02117         osoptions->invokeHelp = false;
    02118         osoptions->writeVersion = false;
    02119         osoptions->quit = false;
    02120         osoptions->exit = false;
    02121
    02122 }//reset_options
    02123
    02124
    02125
    02126 std::string get_options() {
    02127
    02128         std::ostringstream optionMsg;
    02129
    02130
    02131         optionMsg << endl;
    02132
    02133         optionMsg
    02134                         << "***************** VALID COMMANDS AND OPTIONS ********************"
    02135                         << endl ;
    02136         optionMsg
    02137                         << "COMMANDS:"
    02138                         << endl;
    02139         optionMsg
    02140                         << "quit/exit -- terminate the executable"
    02141                         << endl;
    02142         optionMsg
    02143                         << "help/? -- produce this list of options"
    02144                         << endl;
    02145         optionMsg
    02146                         << "reset -- erase all previous option settings"
    02147                         << endl ;
    02148         optionMsg
    02149                         << "list -- list the current option values"
    02150                         << endl ;
    02151         optionMsg
    02152                         << "solve -- call the solver synchronously"
    02153                         << endl ;
    02154         optionMsg
    02155                         << "send -- call the solver asynchronously"
    02156                         << endl ;
    02157         optionMsg
    02158                         << "kill -- end a job on the remote server"
    02159                         << endl ;
    02160         optionMsg
    02161                         << "retrieve -- get job result on the remote server"
    02162                         << endl ;
    02163         optionMsg
    02164                         << "knock -- get job information on the remote server"
    02165                         << endl ;
    02166         optionMsg
    02167                         << "getJobID -- get a job ID from the remote server"
    02168                         << endl << endl;
    02169
    02170
    02171         optionMsg
    02172                         << "OPTIONS (THESE REQUIRE A VALUE):"
    02173                         << endl;
    02174         optionMsg
    02175                         << "osil -- the location of the model instance in OSiL format"
    02176                         << endl;
    02177         optionMsg
    02178                         << "mps  -- the location of the model instance in MPS format"
    02179                         << endl ;
    02180         optionMsg
    02181                         << "nl -- the location of the model instance in AMPL nl format"
    02182                         << endl;
    02183
    02184         optionMsg
    02185                         << "osol -- the location of the solver option file in OSoL format"
    02186                         << endl;
    02187         optionMsg
    02188                         << "osrl -- the location of the solver result file in OSrL format"
    02189                         << endl;
    02190         optionMsg
    02191                         << "osplInput -- the name of an input file in OSpL format"
    02192                         << endl;
    02193         optionMsg
    02194                         << "osplOutput --  the name of an output file in the OSpL format"
    02195                         << endl ;
    02196
    02197         optionMsg
    02198                         << "serviceLocation -- the  URL of a remote solver service"
    02199                         << endl;
    02200
    02201
    02202         optionMsg
    02203                         << "solver -- specify the solver to invoke"
    02204                         << endl <<endl;
    02205
    02206
    02207         optionMsg
    02208                         << "See  http://www.coin-or.org/OS/"
    02209                         << endl;
    02210         optionMsg
    02211                         << "for more detail on how to use the OS project."
    02212                         << endl;
    02213         optionMsg
    02214                         << "*****************************************************************"
    02215                         << endl << endl;
    02216         optionMsg
    02217                         << "At the prompt enter a valid command or option value pair."
    02218                         << endl;
    02219         optionMsg
    02220                         << "Enter the \"solve\" command to optimize."
    02221                         << endl;
    02222         optionMsg
    02223                         << "Type \"quit/exit\" to leave the application."
    02224                         << endl;
    02225         optionMsg
    02226                         << "Type \"help\" or \"?\" for a list of valid options."
    02227                         << endl;
    02228
    02229
    02230         return optionMsg.str();
    02231 }// get_options
    02232
    02233
    02234 void listOptions(osOptionsStruc *osoptions){
    02235 cout
    02236         << "HERE ARE THE OPTION VALUES SO FAR:"
    02237         << endl;
    02238 if (osoptions->configFile != "")
    02239         cout << "Config file = "
    02240                 << osoptions->configFile
    02241                 << endl;
    02242 if (osoptions->osilFile != "")
    02243         cout << "OSiL file = "
    02244                 << osoptions->osilFile
    02245                 << endl;
    02246 if (osoptions->osolFile != "")
    02247         cout << "OSoL file = "
    02248                 << osoptions->osolFile
    02249                 << endl;
    02250 if (osoptions->osrlFile != "")
    02251         cout << "OSrL file = "
    02252                 << osoptions->osrlFile
    02253                 << endl;
    02254 //if(osoptions->insListFile != "") cout << "Instruction List file = " << osoptions->insListFile << endl;
    02255 if (osoptions->osplInputFile != "")
    02256         cout << "OSpL Input file = "
    02257                 << osoptions->osplInputFile
    02258                 << endl;
    02259 if (osoptions->serviceMethod != "")
    02260         cout << "Service Method = "
    02261                 << osoptions->serviceMethod
    02262                 << endl;
    02263 if (osoptions->mpsFile != "")
    02264         cout << "MPS File Name = "
    02265                 << osoptions->mpsFile
    02266                 << endl;
    02267 if (osoptions->nlFile != "")
    02268         cout << "NL File Name = "
    02269                 << osoptions->nlFile
    02270                 << endl;
    02271 if (osoptions->solverName != "")
    02272         cout << "Selected Solver = "
    02273                 << osoptions->solverName
    02274                 << endl;
    02275 if (osoptions->serviceLocation != "")
    02276         cout << "Service Location = "
    02277                 << osoptions->serviceLocation
    02278                 << endl;
    02279
    02280 if (osoptions->jobID != "")
    02281         cout << "Job ID = "
    02282                 << osoptions->jobID
    02283                 << endl;
    02284 }// listOptions
    02285