/home/coin/SVN-release/OS-2.0.1/OS/src/OSCommonInterfaces/OSOption.h

Go to the documentation of this file.
00001 /* $Id: OSOption.h 2747 2009-06-21 15:35:48Z Gassmann $ */
00018 #ifndef OSOPTION_H
00019 #define OSOPTION_H
00020 //#define DEBUG
00021 #include <string>
00022 #include <vector> 
00023 
00035 class InstanceLocationOption {
00036 
00037 public:
00039         std::string locationType;
00040 
00042         std::string value;
00043 
00048         InstanceLocationOption();
00053         ~InstanceLocationOption();
00058         bool IsEqual(InstanceLocationOption *that);
00059 }; //InstanceLocationOption
00060 
00061 
00073 class ContactOption {
00074 
00075 public:
00077         std::string transportType;
00078 
00080         std::string value;
00081 
00086         ContactOption();
00091         ~ContactOption();               
00096         bool IsEqual(ContactOption *that);
00097 }; //ContactOption
00098 
00099 
00111 class OtherOption {
00112 
00113 public:
00115         std::string name;
00116 
00118         std::string value;
00119 
00121         std::string description;
00122  
00127         OtherOption();
00132         ~OtherOption();
00137         bool IsEqual(OtherOption *that);
00138 }; //OtherOption
00139 
00140 
00152 class OtherOptions {
00153 
00154 public:
00156         int numberOfOtherOptions;
00157  
00159         OtherOption **other;
00160 
00165         OtherOptions();
00170         ~OtherOptions();
00175         bool IsEqual(OtherOptions *that);
00182         bool setOther(int numberOfOptions, OtherOption** other);
00190         bool addOther(std::string name, std::string value, std::string description);
00191 }; //OtherOptions
00192 
00193 
00205 class GeneralOption {
00206 
00207 public:
00208 
00210         std::string serviceURI;
00211         
00213         std::string serviceName;
00214 
00216         std::string instanceName;
00217 
00219         InstanceLocationOption *instanceLocation;
00220 
00222         std::string jobID;
00223 
00225         std::string solverToInvoke;
00226 
00228         std::string license;
00229 
00231         std::string userName;
00232 
00234         std::string password;
00235 
00237         ContactOption *contact;
00238 
00240         OtherOptions *otherOptions;
00241 
00246         GeneralOption();
00251         ~GeneralOption();               
00256         bool IsEqual(GeneralOption *that);
00257 };//GeneralOption
00258 
00270 class MinDiskSpace {
00271 
00272 public:
00274         std::string unit;
00275 
00277         double value;
00278 
00279 
00284         MinDiskSpace();
00289         ~MinDiskSpace();
00294         bool IsEqual(MinDiskSpace *that);
00295 }; //MinDiskSpace
00296 
00308 class MinMemorySize {
00309 
00310 public:
00312         std::string unit;
00313 
00315         double value;
00316 
00317 
00322         MinMemorySize();
00327         ~MinMemorySize();
00332         bool IsEqual(MinMemorySize *that);
00333 }; //MinMemorySize
00334 
00346 class MinCPUSpeed {
00347 
00348 public:
00350         std::string unit;
00351 
00353         double value;
00354 
00355 
00360         MinCPUSpeed();
00365         ~MinCPUSpeed();
00370         bool IsEqual(MinCPUSpeed *that);
00371 }; //MinCPUSpeed
00372 
00373 
00385 class SystemOption {
00386 
00387 public:
00389         MinDiskSpace *minDiskSpace;
00390 
00392         MinMemorySize *minMemorySize;
00393 
00395         MinCPUSpeed *minCPUSpeed;
00396 
00398         int minCPUNumber;
00399 
00401         OtherOptions *otherOptions;
00402 
00407         SystemOption();
00412         ~SystemOption();
00417         bool IsEqual(SystemOption *that);
00418 }; //SystemOption
00419 
00420 
00432 class ServiceOption {
00433 
00434 public:
00436         std::string type;
00437 
00439         OtherOptions *otherOptions;
00440 
00445         ServiceOption();
00450         ~ServiceOption();
00455         bool IsEqual(ServiceOption *that);
00456 }; //ServiceOption
00457 
00458 
00470 class MaxTime {
00471 
00472 public:
00474         std::string unit;
00475 
00477         double value;
00478 
00479 
00484         MaxTime();
00489         ~MaxTime();
00494         bool IsEqual(MaxTime *that);
00495 }; //MaxTime
00496 
00497 
00509 class JobDependencies {
00510 
00511 public:
00513         int numberOfJobIDs;
00514 
00516         std::string *jobID;
00517 
00522         JobDependencies();
00527         ~JobDependencies();
00532         bool IsEqual(JobDependencies *that);
00539         bool setJobID(int numberOfJobIDs, std::string *jobID);
00545         bool addJobID(std::string jobID);
00546 }; //JobDependencies
00547 
00548 
00560 class DirectoriesAndFiles {
00561 
00562 public:
00564         int numberOfPaths;
00565 
00567         std::string *path;
00568 
00573         DirectoriesAndFiles();
00578         ~DirectoriesAndFiles();
00583         bool IsEqual(DirectoriesAndFiles *that);
00590         bool setPath(int numberOfPaths, std::string *path);
00596         bool addPath(std::string path);
00597 }; //DirectoriesAndFiles
00598 
00599 
00600 
00612 class PathPair {
00613 
00614 public:
00616         std::string from;
00617 
00619         std::string to;
00620 
00622         bool makeCopy;
00623 
00628         PathPair();
00633         ~PathPair();
00638         bool IsEqual(PathPair *that);
00639 }; //PathPair
00640 
00641 
00653 class PathPairs {
00654 
00655 public:
00657         int numberOfPathPairs;
00658 
00660         PathPair **pathPair;
00661 
00666         PathPairs();
00671         ~PathPairs();
00676         bool IsEqual(PathPairs *that);
00683         bool setPathPair(int numberOfPathPairs, PathPair **pathPair);
00691         bool addPathPair(std::string fromPath, std::string toPath, bool makeCopy);
00692 }; //PathPairs
00693 
00694 
00706 class Processes {
00707 
00708 public:
00710         int numberOfProcesses;
00711 
00713         std::string *process;
00714 
00719         Processes();
00724         ~Processes();           
00729         bool IsEqual(Processes *that);
00736         bool setProcess(int numberOfProcesses, std::string *process);
00742         bool addProcess(std::string process);
00743 }; //Processes
00744 
00745 
00757 class JobOption {
00758 
00759 public:
00761         MaxTime *maxTime;
00762 
00764         std::string requestedStartTime;
00765 
00767         JobDependencies *dependencies;
00768 
00770         DirectoriesAndFiles *requiredDirectories;
00771 
00773         DirectoriesAndFiles *requiredFiles;
00774 
00776         DirectoriesAndFiles *directoriesToMake;
00777 
00779         DirectoriesAndFiles *filesToMake;
00780 
00782         PathPairs *inputDirectoriesToMove;
00783 
00785         PathPairs *inputFilesToMove;
00786 
00788         PathPairs *outputFilesToMove;
00789 
00791         PathPairs *outputDirectoriesToMove;
00792 
00794         DirectoriesAndFiles *filesToDelete;
00795 
00797         DirectoriesAndFiles *directoriesToDelete;
00798 
00800         Processes *processesToKill;
00801 
00803         OtherOptions *otherOptions;
00804 
00809         JobOption();
00814         ~JobOption();   
00819         bool IsEqual(JobOption *that);
00820 }; //JobOption
00821 
00822 
00834 class InitVarValue {
00835 
00836 public:
00838         int idx;
00839 
00841         double value;
00842 
00847         InitVarValue();
00852         ~InitVarValue();                
00857         bool IsEqual(InitVarValue *that);
00858 }; //InitVarValue
00859 
00860 
00872 class InitVariableValues {
00873 
00874 public:
00876         int numberOfVar;
00877 
00879         InitVarValue **var;
00880 
00885         InitVariableValues();
00890         ~InitVariableValues();
00895         bool IsEqual(InitVariableValues *that);
00902         bool setVar(int numberOfVar, InitVarValue **var);
00909         bool addVar(int idx, double value);
00910 }; //InitVariableValues
00911 
00912 
00924 class InitVarValueString {
00925 
00926 public:
00928         int idx;
00929 
00931         std::string value;
00932 
00937         InitVarValueString();
00942         ~InitVarValueString();          
00947         bool IsEqual(InitVarValueString *that);
00948 }; //InitVarValueString
00949 
00950 
00962 class InitVariableValuesString {
00963 
00964 public:
00966         int numberOfVar;
00967 
00969         InitVarValueString **var;
00970 
00975         InitVariableValuesString();
00980         ~InitVariableValuesString();
00985         bool IsEqual(InitVariableValuesString *that);
00992         bool setVar(int numberOfVar, InitVarValueString **var);
00999         bool addVar(int idx, std::string value);
01000 }; //InitVariableValuesString
01001 
01013 class InitBasStatus {
01014 
01015 public:
01017         int idx;
01018 
01020         std::string value;
01021 
01026         InitBasStatus();
01031         ~InitBasStatus();               
01036         bool IsEqual(InitBasStatus *that);
01037 }; //InitBasStatus
01038 
01039 
01051 class InitialBasisStatus {
01052 
01053 public:
01055         int numberOfVar;
01056 
01058         InitBasStatus **var;
01059 
01064         InitialBasisStatus();
01069         ~InitialBasisStatus();
01074         bool IsEqual(InitialBasisStatus *that);
01081         bool setVar(int numberOfVar, InitBasStatus **var);
01088         bool addVar(int idx, std::string value);
01089 }; //InitialBasisStatus
01090 
01102 class BranchingWeight {
01103 
01104 public:
01106         int idx;
01107 
01109         double value;
01110 
01115         BranchingWeight();
01120         ~BranchingWeight();
01125         bool IsEqual(BranchingWeight *that);
01126 }; //BranchingWeight
01127 
01128 
01129 
01141 class IntegerVariableBranchingWeights {
01142 
01143 public:
01145         int numberOfVar;
01146 
01148         BranchingWeight **var;
01149 
01154         IntegerVariableBranchingWeights();
01159         ~IntegerVariableBranchingWeights();
01164         bool IsEqual(IntegerVariableBranchingWeights *that);
01171         bool setVar(int numberOfVar, BranchingWeight **var);
01178         bool addVar(int idx, double value);
01179 }; //IntegerVariableBranchingWeights
01180 
01192 class SOSWeights {
01193 
01194 public:
01196         int sosIdx;
01197 
01199         double groupWeight;
01200 
01202         int numberOfVar;
01203 
01205         BranchingWeight **var;
01206 
01211         SOSWeights();
01216         ~SOSWeights();
01221         bool IsEqual(SOSWeights *that);
01228         bool setVar(int numberOfVar, BranchingWeight **var);
01235         bool addVar(int idx, double value);
01236 }; //SOSWeights
01237 
01238 
01250 class SOSVariableBranchingWeights {
01251 
01252 public:
01254         int numberOfSOS;
01255 
01257         SOSWeights **sos;
01258 
01263         SOSVariableBranchingWeights();
01268         ~SOSVariableBranchingWeights();
01273         bool IsEqual(SOSVariableBranchingWeights *that);
01280         bool setSOS(int numberOfSOS, SOSWeights **sos);
01290         bool addSOS(int sosIdx, int nvar, double weight, int* idx, double* value);
01291 }; //SOSVariableBranchingWeights
01292 
01304 class OtherVarOption {
01305 
01306 public:
01308         int idx;
01309 
01311         std::string value;
01312 
01314         std::string lbValue;
01315 
01317         std::string ubValue;
01318 
01323         OtherVarOption();
01328         ~OtherVarOption();              
01333         bool IsEqual(OtherVarOption *that);
01334 }; //OtherVarOption
01335 
01336 
01348 class OtherVariableOption {
01349 
01350 public:
01352         int numberOfVar;
01353 
01355         std::string name;
01356 
01358         std::string value;
01359 
01361         std::string solver;
01362 
01364         std::string category;
01365 
01367         std::string type;
01368 
01370         std::string description;
01371 
01373         OtherVarOption **var;
01374 
01379         OtherVariableOption();
01384         ~OtherVariableOption();         
01389         bool IsEqual(OtherVariableOption *that);
01396         bool setVar(int numberOfVar, OtherVarOption **var);
01405         bool addVar(int idx, std::string value, std::string lbValue, std::string ubValue);
01406 }; //OtherVariableOption
01407 
01408 
01420 class VariableOption {
01421 
01422 public:
01424         int numberOfOtherVariableOptions;
01425 
01427         InitVariableValues *initialVariableValues;
01428 
01430         InitVariableValuesString *initialVariableValuesString;
01431 
01433         InitialBasisStatus *initialBasisStatus;
01434 
01436         IntegerVariableBranchingWeights *integerVariableBranchingWeights;
01437 
01439         SOSVariableBranchingWeights *sosVariableBranchingWeights;
01440 
01442         OtherVariableOption **other;
01443 
01448         VariableOption();
01453         ~VariableOption();              
01458         bool IsEqual(VariableOption *that);
01465         bool setOther(int numberOfOptions, OtherVariableOption  **other);
01471         bool addOther(OtherVariableOption *other);
01472 }; //VariableOption
01473 
01474 
01486 class InitObjValue {
01487 
01488 public:
01490         int idx;
01491 
01493         double value;
01494 
01499         InitObjValue();
01504         ~InitObjValue();                
01509         bool IsEqual(InitObjValue *that);
01510 }; //InitObjValue
01511 
01512 
01524 class InitObjectiveValues {
01525 
01526 public:
01528         int numberOfObj;
01529 
01531         InitObjValue **obj;
01532 
01537         InitObjectiveValues();
01542         ~InitObjectiveValues();         
01547         bool IsEqual(InitObjectiveValues *that);
01554         bool setObj(int numberOfObj, InitObjValue **obj);
01561         bool addObj(int idx, double value);
01562 }; //InitObjectiveValues
01563 
01564 
01576 class InitObjBound {
01577 
01578 public:
01580         int idx;
01581 
01583         double lbValue;
01584 
01586         double ubValue;
01587 
01592         InitObjBound();
01597         ~InitObjBound();                
01602         bool IsEqual(InitObjBound *that);
01603 }; //InitObjBound
01604 
01605 
01617 class InitObjectiveBounds {
01618 
01619 public:
01621         int numberOfObj;
01622 
01624         InitObjBound **obj;
01625 
01630         InitObjectiveBounds();
01635         ~InitObjectiveBounds();         
01640         bool IsEqual(InitObjectiveBounds *that);
01647         bool setObj(int numberOfObj, InitObjBound **obj);
01655         bool addObj(int idx, double lbValue, double ubValue);
01656 }; //InitObjectiveBounds
01657 
01658 
01670 class OtherObjOption {
01671 
01672 public:
01674         int idx;
01675 
01677         std::string value;
01678 
01679 
01681         std::string lbValue;
01682 
01684         std::string ubValue;
01689         OtherObjOption();
01694         ~OtherObjOption();              
01699         bool IsEqual(OtherObjOption *that);
01700 }; //OtherObjOption
01701 
01702 
01714 class OtherObjectiveOption {
01715 
01716 public:
01718         int numberOfObj;
01719 
01721         std::string name;
01722 
01724         std::string value;
01725 
01727         std::string solver;
01728 
01730         std::string category;
01731 
01733         std::string type;
01734 
01736         std::string description;
01737 
01739         OtherObjOption **obj;
01740 
01745         OtherObjectiveOption();
01750         ~OtherObjectiveOption();                
01755         bool IsEqual(OtherObjectiveOption *that);
01762         bool setObj(int numberOfObj, OtherObjOption **obj);
01771         bool addObj(int idx, std::string value, std::string lbValue, std::string ubValue);
01772 }; //OtherObjectiveOption
01773 
01774 
01786 class ObjectiveOption {
01787 
01788 public:
01790         int numberOfOtherObjectiveOptions;
01791 
01793         InitObjectiveValues *initialObjectiveValues;
01794 
01796         InitObjectiveBounds *initialObjectiveBounds;
01797 
01799         OtherObjectiveOption **other;
01800 
01805         ObjectiveOption();
01810         ~ObjectiveOption();             
01815         bool IsEqual(ObjectiveOption *that);
01822         bool setOther(int numberOfOptions, OtherObjectiveOption  **other);
01828         bool addOther(OtherObjectiveOption *other);
01829 }; //ObjectiveOption
01830 
01831 
01843 class InitConValue {
01844 
01845 public:
01847         int idx;
01848 
01850         double value;
01851 
01856         InitConValue();
01861         ~InitConValue();                
01866         bool IsEqual(InitConValue *that);
01867 }; //InitConValue
01868 
01869 
01881 class InitConstraintValues {
01882 
01883 public:
01885         int numberOfCon;
01886 
01888         InitConValue **con;
01889 
01894         InitConstraintValues();
01899         ~InitConstraintValues();                
01904         bool IsEqual(InitConstraintValues *that);
01911         bool setCon(int numberOfCon, InitConValue **con);
01918         bool addCon(int idx, double value);
01919 }; //InitConstraintValues
01920 
01921 
01933 class InitDualVarValue {
01934 
01935 public:
01937         int idx;
01938 
01940         double lbDualValue;
01941 
01943         double ubDualValue;
01944 
01949         InitDualVarValue();
01954         ~InitDualVarValue();            
01959         bool IsEqual(InitDualVarValue *that);
01960 }; //InitDualVarValue
01961 
01962 
01974 class InitDualVariableValues {
01975 
01976 public:
01978         int numberOfCon;
01979 
01981         InitDualVarValue **con;
01982 
01987         InitDualVariableValues();
01992         ~InitDualVariableValues();              
01997         bool IsEqual(InitDualVariableValues *that);
02004         bool setCon(int numberOfCon, InitDualVarValue **con);
02012         bool addCon(int idx, double lbDualValue, double ubDualValue);
02013 }; //InitDualVariableValues
02014 
02015 
02027 class OtherConOption {
02028 
02029 public:
02031         int idx;
02032 
02034         std::string value;
02035 
02037         std::string lbValue;
02038 
02040         std::string ubValue;
02041 
02046         OtherConOption();
02051         ~OtherConOption();              
02056         bool IsEqual(OtherConOption *that);
02057 }; //OtherConOption
02058 
02059 
02071 class OtherConstraintOption {
02072 
02073 public:
02075         int numberOfCon;
02076 
02078         std::string name;
02079 
02081         std::string value;
02082 
02084         std::string solver;
02085 
02087         std::string category;
02088 
02090         std::string type;
02091 
02093         std::string description;
02094 
02096         OtherConOption **con;
02097 
02102         OtherConstraintOption();
02107         ~OtherConstraintOption();               
02112         bool IsEqual(OtherConstraintOption *that);
02119         bool setCon(int numberOfCon, OtherConOption **con);
02128         bool addCon(int idx, std::string value, std::string lbValue, std::string ubValue);
02129 }; //OtherConstraintOption
02130 
02131 
02143 class ConstraintOption {
02144 
02145 public:
02147         int numberOfOtherConstraintOptions;
02148 
02150         InitConstraintValues *initialConstraintValues;
02151 
02153         InitDualVariableValues *initialDualValues;
02154 
02156         OtherConstraintOption **other;
02157 
02162         ConstraintOption();
02167         ~ConstraintOption();            
02172         bool IsEqual(ConstraintOption *that);
02179         bool setOther(int numberOfOptions, OtherConstraintOption  **other);
02185         bool addOther(OtherConstraintOption *other);
02186 }; //ConstraintOption
02187 
02188 
02200 class SolverOption {
02201 
02202 public:
02204         std::string name;
02205 
02207         std::string value;
02208 
02210         std::string solver;
02211 
02213         std::string category;
02214 
02216         std::string type;
02217 
02219         std::string description;
02220 
02225         SolverOption();
02230         ~SolverOption();                
02235         bool IsEqual(SolverOption *that);
02236 }; //SolverOption
02237 
02238 
02250 class SolverOptions {
02251 
02252 public:
02254         int numberOfSolverOptions;
02255 
02257         SolverOption **solverOption;
02258 
02263         SolverOptions();
02268         ~SolverOptions();               
02273         bool IsEqual(SolverOptions *that);
02280         bool setSolverOptions(int numberOfOptions, SolverOption **solverOption);
02291         bool addSolverOption(std::string name, std::string value, std::string solver, 
02292                  std::string category, std::string type, std::string description);
02293 }; //SolverOptions
02294 
02295 
02307 class OptimizationOption {
02308 
02309 public:
02311         int numberOfVariables;
02312 
02314         int numberOfObjectives;
02315 
02317         int numberOfConstraints;
02318 
02320         VariableOption *variables;
02321 
02323         ObjectiveOption *objectives;
02324 
02326         ConstraintOption *constraints;
02327 
02329         SolverOptions *solverOptions;
02334         OptimizationOption();
02339         ~OptimizationOption();  
02344         bool IsEqual(OptimizationOption *that);
02345 }; //OptimizationOption
02346 
02347 
02358 class OSOption{
02359 
02360 public:
02361 
02367         GeneralOption *general;
02371         SystemOption *system;
02375         ServiceOption *service;
02379         JobOption *job;
02383         OptimizationOption *optimization;
02384 
02389         OSOption(); 
02394         ~OSOption();
02395 
02396 private:
02400         double* m_mdInitVarValuesDense;
02401 
02405         std::string* m_mdInitVarValuesStringDense;
02406 
02410         std::string* m_mdInitBasisStatusDense;
02411 
02415         double* m_mdIntegerVariableBranchingWeightsDense;
02416 
02420         double* m_mdInitObjValuesDense;
02421 
02425         double* m_mdInitObjLowerBoundsDense;
02426 
02430         double* m_mdInitObjUpperBoundsDense;
02431 
02435         double* m_mdInitConValuesDense;
02436 
02441         double* m_mdInitDualVarLowerBoundsDense;
02442 
02447         double* m_mdInitDualVarUpperBoundsDense;
02448 public:
02453         bool IsEqual(OSOption *that);
02454 
02455 public: 
02456         
02457         // get() methods...
02458         
02462         std::string  getServiceURI();
02463 
02467         std::string  getServiceName();
02468 
02472         std::string  getInstanceName();
02473 
02477         std::string  getInstanceLocation();
02478 
02482         std::string  getInstanceLocationType();
02483 
02487         std::string  getJobID();
02488 
02492         std::string  getSolverToInvoke();
02493 
02497         std::string  getLicense();
02498 
02502         std::string  getUserName();
02503 
02507         std::string  getPassword();
02508 
02512         std::string  getContact();
02513 
02517         std::string  getContactTransportType();
02518 
02522         std::string  getMinDiskSpaceUnit();
02523 
02527         std::string  getMinMemoryUnit();
02528 
02532         std::string  getMinCPUSpeedUnit();
02533 
02537         std::string  getServiceType();
02538 
02542         std::string  getMaxTimeUnit();
02543 
02547         std::string  getRequestedStartTime();
02548 
02552         std::string  getOptionStr(std::string optionName);
02553 
02557         double  getMinDiskSpace();
02558 
02562         double  getMinMemorySize();
02563 
02567         double  getMinCPUSpeed();
02568 
02572         double  getMaxTime();
02573 
02577         double  getOptionDbl(std::string optionName);
02578 
02582         int  getMinCPUNumber();
02583 
02587         int  getNumberOfOtherGeneralOptions();
02588 
02592         int  getNumberOfOtherSystemOptions();
02593 
02597         int  getNumberOfOtherServiceOptions();
02598 
02602         int  getNumberOfOtherJobOptions();
02603 
02607         int  getNumberOfJobDependencies();
02608 
02612         int  getNumberOfRequiredDirectories();
02613 
02617         int  getNumberOfRequiredFiles();
02618 
02622         int  getNumberOfDirectoriesToMake();
02623 
02627         int  getNumberOfFilesToMake();
02628 
02632         int  getNumberOfInputDirectoriesToMove();
02633 
02637         int  getNumberOfInputFilesToMove();
02638 
02642         int  getNumberOfOutputDirectoriesToMove();
02643 
02647         int  getNumberOfOutputFilesToMove();
02648 
02652         int  getNumberOfFilesToDelete();
02653 
02657         int  getNumberOfDirectoriesToDelete();
02658 
02662         int  getNumberOfProcessesToKill();
02663 
02667         int  getNumberOfVariables();
02668 
02672         int  getNumberOfObjectives();
02673 
02677         int  getNumberOfConstraints();
02678 
02684         int getNumberOfInitVarValues();
02685 
02691         int getNumberOfInitVarValuesString();
02692 
02698         int getNumberOfInitialBasisVariables();
02699 
02705         int getNumberOfIntegerVariableBranchingWeights();
02706 
02712         int getNumberOfSOS();
02713 
02719         int getNumberOfSOSVarBranchingWeights(int iSOS);
02720 
02726         int getNumberOfOtherVariableOptions();
02727         
02733         int getNumberOfInitObjValues();
02734 
02740         int getNumberOfInitObjBounds();
02741 
02747         int getNumberOfOtherObjectiveOptions();
02748         
02754         int getNumberOfInitConValues();
02755 
02761         int getNumberOfInitDualVarValues();
02762 
02768         int getNumberOfOtherConstraintOptions();
02769         
02775         int getNumberOfSolverOptions();
02776         
02780         int getOptionInt(std::string optionName);
02781 
02782 
02790         OtherOption** getOtherGeneralOptions();
02791 
02799         OtherOption** getOtherSystemOptions();
02800 
02808         OtherOption** getOtherServiceOptions();
02809 
02817         OtherOption** getOtherJobOptions();
02818 
02826         OtherOption** getOtherOptions(std::string elementName);
02827 
02835         OtherOption** getAllOtherOptions();
02836 
02843         std::string* getJobDependencies();
02844 
02852         std::string* getRequiredDirectories();
02853 
02861         std::string* getRequiredFiles();
02862 
02870         std::string* getDirectoriesToMake();
02871 
02879         std::string* getFilesToMake();
02880 
02888         PathPair** getInputDirectoriesToMove();
02889 
02897         PathPair** getInputFilesToMove();
02898 
02906         PathPair** getOutputDirectoriesToMove();
02907 
02915         PathPair** getOutputFilesToMove();
02916 
02924         std::string* getDirectoriesToDelete();
02925 
02933         std::string* getFilesToDelete();
02934 
02942         std::string* getProcessesToKill();
02943 
02951         InitVarValue** getInitVarValuesSparse();
02952 
02960         double* getInitVarValuesDense();
02961 
02970         double* getInitVarValuesDense(int numberOfVariables);
02971 
02979         InitVarValueString** getInitVarValuesStringSparse();
02980 
02988         std::string *getInitVarValuesStringDense();
02989 
02998         std::string *getInitVarValuesStringDense(int numberOfVariables);
02999 
03007         InitBasStatus** getInitBasisStatusSparse();
03008 
03016         std::string *getInitBasisStatusDense();
03017 
03026         std::string *getInitBasisStatusDense(int numberOfVariables);
03027 
03028 
03036         BranchingWeight**  getIntegerVariableBranchingWeightsSparse();
03037 
03045         double* getIntegerVariableBranchingWeightsDense();
03046 
03055         double* getIntegerVariableBranchingWeightsDense(int numberOfVariables);
03056 
03064         SOSWeights** getSOSVariableBranchingWeightsSparse(); 
03065 
03074         std::vector<OtherVariableOption*> getOtherVariableOptions(std::string solver_name);
03075 
03082         OtherVariableOption** getAllOtherVariableOptions();
03083 
03091         InitObjValue** getInitObjValuesSparse();
03092 
03100         double *getInitObjValuesDense();
03101 
03110         double *getInitObjValuesDense(int numberOfObjectives);
03111 
03119         InitObjBound** getInitObjBoundsSparse();
03120 
03128         double *getInitObjLowerBoundsDense();
03129 
03138         double *getInitObjLowerBoundsDense(int numberOfObjectives);
03139 
03147         double *getInitObjUpperBoundsDense();
03148 
03157         double *getInitObjUpperBoundsDense(int numberOfObjectives);
03158 
03166         std::vector<OtherObjectiveOption*> getOtherObjectiveOptions(std::string solver_name);
03167 
03174         OtherObjectiveOption** getAllOtherObjectiveOptions();
03175 
03183         InitConValue** getInitConValuesSparse();
03184 
03192         double *getInitConValuesDense();
03193 
03202         double *getInitConValuesDense(int numberOfConstraints);
03203 
03211         InitDualVarValue** getInitDualVarValuesSparse();
03212 
03220         double *getInitDualVarLowerBoundsDense();
03221 
03230         double *getInitDualVarLowerBoundsDense(int numberOfConstraints);
03231 
03232 
03240         double *getInitDualVarUpperBoundsDense();
03241 
03250         double *getInitDualVarUpperBoundsDense(int numberOfConstraints);
03251 
03259         std::vector<OtherConstraintOption*> getOtherConstraintOptions(std::string solver_name);
03260 
03261 
03268         OtherConstraintOption** getAllOtherConstraintOptions();
03269 
03278         std::vector<SolverOption*> getSolverOptions( std::string solver_name);
03279 
03286         SolverOption** getAllSolverOptions();
03287 
03288         /* --------------------------------------------------
03289  *  set() methods
03290  * -------------------------------------------------- */
03291 
03295         bool setServiceURI( std::string serviceURI);
03296 
03300         bool setServiceName( std::string serviceName);
03301 
03305         bool setInstanceName( std::string instanceName);
03306 
03310         bool setInstanceLocation( std::string instanceLocation);
03311 
03315         bool setInstanceLocationType( std::string locationType);
03316 
03320         bool setJobID( std::string jobID);
03321 
03325         bool setSolverToInvoke( std::string solverToInvoke);
03326 
03330         bool setLicense( std::string license);
03331 
03335         bool setUserName( std::string userName);
03336 
03340         bool setPassword( std::string password);
03341 
03345         bool setContact( std::string contact);
03346 
03350         bool setContactTransportType( std::string transportType);
03351 
03355         bool setOtherGeneralOptions(int numberOfOptions, OtherOption** other);
03356 
03360         bool setAnOtherGeneralOption(std::string name, std::string value, std::string description);
03361 
03362 
03363         bool setMinDiskSpace(double value);
03364 
03365         bool setMinDiskSpaceUnit(std::string unit);
03366 
03367         bool setMinMemorySize(double value);
03368 
03369         bool setMinMemoryUnit(std::string unit);
03370 
03371         bool setMinCPUSpeed(double value);
03372 
03373         bool setMinCPUSpeedUnit(std::string unit);
03374 
03375         bool setMinCPUNumber( int number);
03376 
03377         bool setOtherSystemOptions(int numberOfOptions, OtherOption** other);
03378 
03379         bool setAnOtherSystemOption(std::string name, std::string value, std::string description);
03380 
03381 
03382         bool setServiceType( std::string serviceType);
03383 
03384         bool setOtherServiceOptions(int numberOfOptions, OtherOption** other);
03385 
03386         bool setAnOtherServiceOption(std::string name, std::string value, std::string description);
03387 
03388 
03389         bool setMaxTime(double value);
03390 
03391         bool setMaxTimeUnit(std::string unit);
03392 
03393         bool setRequestedStartTime(std::string time);
03394 
03395         bool setJobDependencies(int numberOfDependencies, std::string* jobDependencies);
03396         bool setAnotherJobDependency(std::string jobID);
03397 
03398         bool setRequiredDirectories(int numberOfPaths, std::string* paths);
03399         bool setAnotherRequiredDirectory(std::string path);
03400 
03401         bool setRequiredFiles(int numberOfPaths, std::string* paths);
03402         bool setAnotherRequiredFile(std::string path);
03403 
03404         bool setDirectoriesToMake(int numberOfPaths, std::string* paths);
03405         bool setAnotherDirectoryToMake(std::string path);
03406 
03407         bool setFilesToMake(int numberOfPaths, std::string* paths);
03408         bool setAnotherFileToMake(std::string path);
03409 
03410         bool setInputDirectoriesToMove(int numberOfPathPairs, PathPair** pathPair);
03411         bool setAnotherInputDirectoryToMove(std::string fromPath, std::string toPath, bool makeCopy);
03412 
03413         bool setInputFilesToMove(int numberOfPathPairs, PathPair** pathPair);
03414         bool setAnotherInputFileToMove(std::string fromPath, std::string toPath, bool makeCopy);
03415 
03416         bool setOutputFilesToMove(int numberOfPathPairs, PathPair** pathPair);
03417         bool setAnotherOutputFileToMove(std::string fromPath, std::string toPath, bool makeCopy);
03418 
03419         bool setOutputDirectoriesToMove(int numberOfPathPairs, PathPair** pathPair);
03420         bool setAnotherOutputDirectoryToMove(std::string fromPath, std::string toPath, bool makeCopy);
03421 
03422         bool setFilesToDelete(int numberOfPaths, std::string* paths);
03423         bool setAnotherFileToDelete(std::string path);
03424 
03425         bool setDirectoriesToDelete(int numberOfPaths, std::string* paths);
03426         bool setAnotherDirectoryToDelete(std::string path);
03427 
03428         bool setProcessesToKill(int numberOfProcesses, std::string* processes);
03429         bool setAnotherProcessToKill(std::string process);
03430 
03431         bool setOtherJobOptions(int numberOfOptions, OtherOption** other);
03432         bool setAnOtherJobOption(std::string name, std::string value, std::string description);
03433 
03434 
03435         bool setNumberOfVariables(int numberOfObjects);
03436 
03437         bool setNumberOfObjectives(int numberOfObjects);
03438 
03439         bool setNumberOfConstraints(int numberOfObjects);
03440 
03441         bool setInitVarValuesSparse(int numberOfVar, InitVarValue** var);
03442         bool setInitVarValuesDense(int numberOfVar, double *value);
03443         bool setAnotherInitVarValue(int idx, double value);
03444 
03445         bool setInitVarValuesStringSparse(int numberOfVar, InitVarValueString** var);
03446         bool setInitVarValuesStringDense(int numberOfVar, std::string *value);
03447         bool setAnotherInitVarValueString(int idx, std::string value);
03448 
03449         bool setInitBasisStatusSparse(int numberOfVar, InitBasStatus** var);
03450         bool setInitBasisStatusDense(int numberOfVar, std::string *var);
03451         bool setAnotherInitBasisStatus(int idx, std::string value);
03452 
03453         bool setIntegerVariableBranchingWeightsSparse(int numberOfVar, BranchingWeight** var);
03454         bool setIntegerVariableBranchingWeightsDense(int numberOfVar, double *value);
03455         bool setAnotherIntegerVariableBranchingWeight(int idx, double value);
03456 
03457         bool setSOSVariableBranchingWeights(int numberOfSOS, SOSWeights** sos);
03458         bool setAnotherSOSVariableBranchingWeight(int sosIdx, int nvar, double weight, int* idx, double* value);
03459 
03460         bool setOtherVariableOptions(int numberOfVar, OtherVariableOption** var);
03461         bool setAnOtherVariableOption(OtherVariableOption* varOption);
03462 
03463         bool setInitObjValuesSparse(int numberOfObj, InitObjValue** obj);
03464         bool setInitObjValuesDense(int numberOfObj, double *value);
03465         bool setAnotherInitObjValue(int idx, double value);
03466 
03467         bool setInitObjBoundsSparse(int numberOfObj, InitObjBound** obj);
03468         bool setInitObjBoundsDense(int numberOfObj, double *lb, double *ub);
03469         bool setAnotherInitObjBound(int idx, double lbValue, double ubValue);
03470 
03471         bool setOtherObjectiveOptions(int numberOfObj, OtherObjectiveOption** obj);
03472         bool setAnOtherObjectiveOption(OtherObjectiveOption* objOption);
03473 
03474         bool setInitConValuesSparse(int numberOfCon, InitConValue** con);
03475         bool setInitConValuesDense(int numberOfCon, double *value);
03476         bool setAnotherInitConValue(int idx, double value);
03477 
03478         bool setInitDualVarValuesSparse(int numberOfCon, InitDualVarValue** con);
03479         bool setInitDualVarValuesDense(int numberOfCon, double *lb, double *ub);
03480         bool setAnotherInitDualVarValue(int idx, double lbValue, double ubValue);
03481 
03482         bool setOtherConstraintOptions(int numberOfOptions, OtherConstraintOption** other);
03483         bool setAnOtherConstraintOption(OtherConstraintOption* optionValue);
03484 
03485         bool setSolverOptions(int numberOfSolverOptions, SolverOption** solverOption);
03486         bool setAnotherSolverOption(std::string name, std::string value, std::string solver, 
03487                  std::string category, std::string type, std::string description);
03488 
03489         bool setOptionInt(std::string optionName, int optionValue);
03490 
03491         bool setOptionStr(std::string optionName, std::string optionValue);
03492 
03493         bool setOptionDbl(std::string optionName, double value);
03494 
03495 };//OSOption
03496 #endif

Generated on Thu Oct 8 03:02:59 2009 by  doxygen 1.4.7