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

Go to the documentation of this file.
00001 /* $Id: OSOption.h 3038 2009-11-07 11:43:44Z 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();
00054 
00059         bool IsEqual(InstanceLocationOption *that);
00060 }; //InstanceLocationOption
00061 
00062 
00074 class ContactOption {
00075 
00076 public:
00078         std::string transportType;
00079 
00081         std::string value;
00082 
00087         ContactOption();
00092         ~ContactOption();
00093 
00098         bool IsEqual(ContactOption *that);
00099 }; //ContactOption
00100 
00101 
00113 class OtherOption {
00114 
00115 public:
00117         std::string name;
00118 
00120         std::string value;
00121 
00123         std::string description;
00124  
00129         OtherOption();
00134         ~OtherOption();
00135 
00140         bool IsEqual(OtherOption *that);
00141 }; //OtherOption
00142 
00143 
00155 class OtherOptions {
00156 
00157 public:
00159         int numberOfOtherOptions;
00160  
00162         OtherOption **other;
00163 
00168         OtherOptions();
00173         ~OtherOptions();
00174 
00179         bool IsEqual(OtherOptions *that);
00186         bool setOther(int numberOfOptions, OtherOption** other);
00194         bool addOther(std::string name, std::string value, std::string description);
00195 }; //OtherOptions
00196 
00197 
00209 class GeneralOption {
00210 
00211 public:
00212 
00214         std::string serviceURI;
00215         
00217         std::string serviceName;
00218 
00220         std::string instanceName;
00221 
00223         InstanceLocationOption *instanceLocation;
00224 
00226         std::string jobID;
00227 
00229         std::string solverToInvoke;
00230 
00232         std::string license;
00233 
00235         std::string userName;
00236 
00238         std::string password;
00239 
00241         ContactOption *contact;
00242 
00244         OtherOptions *otherOptions;
00245 
00250         GeneralOption();
00255         ~GeneralOption();               
00256 
00261         bool IsEqual(GeneralOption *that);
00262 };//GeneralOption
00263 
00275 class MinDiskSpace {
00276 
00277 public:
00279         std::string unit;
00280 
00282         double value;
00283 
00284 
00289         MinDiskSpace();
00294         ~MinDiskSpace();
00295 
00300         bool IsEqual(MinDiskSpace *that);
00301 }; //MinDiskSpace
00302 
00314 class MinMemorySize {
00315 
00316 public:
00318         std::string unit;
00319 
00321         double value;
00322 
00323 
00328         MinMemorySize();
00333         ~MinMemorySize();
00334 
00339         bool IsEqual(MinMemorySize *that);
00340 }; //MinMemorySize
00341 
00353 class MinCPUSpeed {
00354 
00355 public:
00357         std::string unit;
00358 
00360         double value;
00361 
00362 
00367         MinCPUSpeed();
00372         ~MinCPUSpeed();
00373 
00378         bool IsEqual(MinCPUSpeed *that);
00379 }; //MinCPUSpeed
00380 
00381 
00393 class SystemOption {
00394 
00395 public:
00397         MinDiskSpace *minDiskSpace;
00398 
00400         MinMemorySize *minMemorySize;
00401 
00403         MinCPUSpeed *minCPUSpeed;
00404 
00406         int minCPUNumber;
00407 
00409         OtherOptions *otherOptions;
00410 
00415         SystemOption();
00420         ~SystemOption();
00421 
00426         bool IsEqual(SystemOption *that);
00427 }; //SystemOption
00428 
00429 
00441 class ServiceOption {
00442 
00443 public:
00445         std::string type;
00446 
00448         OtherOptions *otherOptions;
00449 
00454         ServiceOption();
00459         ~ServiceOption();
00460 
00465         bool IsEqual(ServiceOption *that);
00466 }; //ServiceOption
00467 
00468 
00480 class MaxTime {
00481 
00482 public:
00484         std::string unit;
00485 
00487         double value;
00488 
00489 
00494         MaxTime();
00499         ~MaxTime();
00500 
00505         bool IsEqual(MaxTime *that);
00506 }; //MaxTime
00507 
00508 
00520 class JobDependencies {
00521 
00522 public:
00524         int numberOfJobIDs;
00525 
00527         std::string *jobID;
00528 
00533         JobDependencies();
00538         ~JobDependencies();
00539 
00544         bool IsEqual(JobDependencies *that);
00551         bool setJobID(int numberOfJobIDs, std::string *jobID);
00557         bool addJobID(std::string jobID);
00558 }; //JobDependencies
00559 
00560 
00572 class DirectoriesAndFiles {
00573 
00574 public:
00576         int numberOfPaths;
00577 
00579         std::string *path;
00580 
00585         DirectoriesAndFiles();
00590         ~DirectoriesAndFiles();
00591 
00596         bool IsEqual(DirectoriesAndFiles *that);
00603         bool setPath(int numberOfPaths, std::string *path);
00609         bool addPath(std::string path);
00610 }; //DirectoriesAndFiles
00611 
00612 
00613 
00625 class PathPair {
00626 
00627 public:
00629         std::string from;
00630 
00632         std::string to;
00633 
00635         bool makeCopy;
00636 
00641         PathPair();
00646         ~PathPair();
00647 
00652         bool IsEqual(PathPair *that);
00653 }; //PathPair
00654 
00655 
00667 class PathPairs {
00668 
00669 public:
00671         int numberOfPathPairs;
00672 
00674         PathPair **pathPair;
00675 
00680         PathPairs();
00685         ~PathPairs();
00686 
00691         bool IsEqual(PathPairs *that);
00698         bool setPathPair(int numberOfPathPairs, PathPair **pathPair);
00706         bool addPathPair(std::string fromPath, std::string toPath, bool makeCopy);
00707 }; //PathPairs
00708 
00709 
00721 class Processes {
00722 
00723 public:
00725         int numberOfProcesses;
00726 
00728         std::string *process;
00729 
00734         Processes();
00739         ~Processes();           
00740 
00745         bool IsEqual(Processes *that);
00752         bool setProcess(int numberOfProcesses, std::string *process);
00758         bool addProcess(std::string process);
00759 }; //Processes
00760 
00761 
00773 class JobOption {
00774 
00775 public:
00777         MaxTime *maxTime;
00778 
00780         std::string requestedStartTime;
00781 
00783         JobDependencies *dependencies;
00784 
00786         DirectoriesAndFiles *requiredDirectories;
00787 
00789         DirectoriesAndFiles *requiredFiles;
00790 
00792         DirectoriesAndFiles *directoriesToMake;
00793 
00795         DirectoriesAndFiles *filesToMake;
00796 
00798         PathPairs *inputDirectoriesToMove;
00799 
00801         PathPairs *inputFilesToMove;
00802 
00804         PathPairs *outputFilesToMove;
00805 
00807         PathPairs *outputDirectoriesToMove;
00808 
00810         DirectoriesAndFiles *filesToDelete;
00811 
00813         DirectoriesAndFiles *directoriesToDelete;
00814 
00816         Processes *processesToKill;
00817 
00819         OtherOptions *otherOptions;
00820 
00825         JobOption();
00830         ~JobOption();   
00831 
00836         bool IsEqual(JobOption *that);
00837 }; //JobOption
00838 
00839 
00851 class InitVarValue {
00852 
00853 public:
00855         int idx;
00856 
00858         double value;
00859 
00864         InitVarValue();
00869         ~InitVarValue();
00870 
00875         bool IsEqual(InitVarValue *that);
00876 }; //InitVarValue
00877 
00878 
00890 class InitVariableValues {
00891 
00892 public:
00894         int numberOfVar;
00895 
00897         InitVarValue **var;
00898 
00903         InitVariableValues();
00908         ~InitVariableValues();
00909 
00914         bool IsEqual(InitVariableValues *that);
00921         bool setVar(int numberOfVar, InitVarValue **var);
00928         bool addVar(int idx, double value);
00929 }; //InitVariableValues
00930 
00931 
00943 class InitVarValueString {
00944 
00945 public:
00947         int idx;
00948 
00950         std::string value;
00951 
00956         InitVarValueString();
00961         ~InitVarValueString();
00962 
00967         bool IsEqual(InitVarValueString *that);
00968 }; //InitVarValueString
00969 
00970 
00982 class InitVariableValuesString {
00983 
00984 public:
00986         int numberOfVar;
00987 
00989         InitVarValueString **var;
00990 
00995         InitVariableValuesString();
01000         ~InitVariableValuesString();
01001 
01006         bool IsEqual(InitVariableValuesString *that);
01013         bool setVar(int numberOfVar, InitVarValueString **var);
01020         bool addVar(int idx, std::string value);
01021 }; //InitVariableValuesString
01022 
01034 class InitBasStatus {
01035 
01036 public:
01038         int idx;
01039 
01041         std::string value;
01042 
01047         InitBasStatus();
01052         ~InitBasStatus();               
01053 
01058         bool IsEqual(InitBasStatus *that);
01059 }; //InitBasStatus
01060 
01061 
01073 class InitialBasisStatus {
01074 
01075 public:
01077         int numberOfVar;
01078 
01080         InitBasStatus **var;
01081 
01086         InitialBasisStatus();
01091         ~InitialBasisStatus();
01092 
01097         bool IsEqual(InitialBasisStatus *that);
01104         bool setVar(int numberOfVar, InitBasStatus **var);
01111         bool addVar(int idx, std::string value);
01112 }; //InitialBasisStatus
01113 
01125 class BranchingWeight {
01126 
01127 public:
01129         int idx;
01130 
01132         double value;
01133 
01138         BranchingWeight();
01143         ~BranchingWeight();
01144 
01149         bool IsEqual(BranchingWeight *that);
01150 }; //BranchingWeight
01151 
01152 
01153 
01165 class IntegerVariableBranchingWeights {
01166 
01167 public:
01169         int numberOfVar;
01170 
01172         BranchingWeight **var;
01173 
01178         IntegerVariableBranchingWeights();
01183         ~IntegerVariableBranchingWeights();
01184 
01189         bool IsEqual(IntegerVariableBranchingWeights *that);
01196         bool setVar(int numberOfVar, BranchingWeight **var);
01203         bool addVar(int idx, double value);
01204 }; //IntegerVariableBranchingWeights
01205 
01217 class SOSWeights {
01218 
01219 public:
01221         int sosIdx;
01222 
01224         double groupWeight;
01225 
01227         int numberOfVar;
01228 
01230         BranchingWeight **var;
01231 
01236         SOSWeights();
01241         ~SOSWeights();
01242 
01247         bool IsEqual(SOSWeights *that);
01254         bool setVar(int numberOfVar, BranchingWeight **var);
01261         bool addVar(int idx, double value);
01262 }; //SOSWeights
01263 
01264 
01276 class SOSVariableBranchingWeights {
01277 
01278 public:
01280         int numberOfSOS;
01281 
01283         SOSWeights **sos;
01284 
01289         SOSVariableBranchingWeights();
01294         ~SOSVariableBranchingWeights();
01295 
01300         bool IsEqual(SOSVariableBranchingWeights *that);
01307         bool setSOS(int numberOfSOS, SOSWeights **sos);
01317         bool addSOS(int sosIdx, int nvar, double weight, int* idx, double* value);
01318 }; //SOSVariableBranchingWeights
01319 
01331 class OtherVarOption {
01332 
01333 public:
01335         int idx;
01336 
01338         std::string value;
01339 
01341         std::string lbValue;
01342 
01344         std::string ubValue;
01345 
01350         OtherVarOption();
01355         ~OtherVarOption();
01356 
01361         bool IsEqual(OtherVarOption *that);
01362 }; //OtherVarOption
01363 
01364 
01376 class OtherVariableOption {
01377 
01378 public:
01380         int numberOfVar;
01381 
01383         std::string name;
01384 
01386         std::string value;
01387 
01389         std::string solver;
01390 
01392         std::string category;
01393 
01395         std::string type;
01396 
01398         std::string description;
01399 
01401         OtherVarOption **var;
01402 
01407         OtherVariableOption();
01412         ~OtherVariableOption(); 
01413 
01418         bool IsEqual(OtherVariableOption *that);
01425         bool setVar(int numberOfVar, OtherVarOption **var);
01434         bool addVar(int idx, std::string value, std::string lbValue, std::string ubValue);
01435 }; //OtherVariableOption
01436 
01437 
01449 class VariableOption {
01450 
01451 public:
01453         int numberOfOtherVariableOptions;
01454 
01456         InitVariableValues *initialVariableValues;
01457 
01459         InitVariableValuesString *initialVariableValuesString;
01460 
01462         InitialBasisStatus *initialBasisStatus;
01463 
01465         IntegerVariableBranchingWeights *integerVariableBranchingWeights;
01466 
01468         SOSVariableBranchingWeights *sosVariableBranchingWeights;
01469 
01471         OtherVariableOption **other;
01472 
01477         VariableOption();
01482         ~VariableOption();
01483 
01488         bool IsEqual(VariableOption *that);
01495         bool setOther(int numberOfOptions, OtherVariableOption  **other);
01501         bool addOther(OtherVariableOption *other);
01502 }; //VariableOption
01503 
01504 
01516 class InitObjValue {
01517 
01518 public:
01520         int idx;
01521 
01523         double value;
01524 
01529         InitObjValue();
01534         ~InitObjValue();
01535 
01540         bool IsEqual(InitObjValue *that);
01541 }; //InitObjValue
01542 
01543 
01555 class InitObjectiveValues {
01556 
01557 public:
01559         int numberOfObj;
01560 
01562         InitObjValue **obj;
01563 
01568         InitObjectiveValues();
01573         ~InitObjectiveValues();
01574 
01579         bool IsEqual(InitObjectiveValues *that);
01586         bool setObj(int numberOfObj, InitObjValue **obj);
01593         bool addObj(int idx, double value);
01594 }; //InitObjectiveValues
01595 
01596 
01608 class InitObjBound {
01609 
01610 public:
01612         int idx;
01613 
01615         double lbValue;
01616 
01618         double ubValue;
01619 
01624         InitObjBound();
01629         ~InitObjBound();
01630 
01635         bool IsEqual(InitObjBound *that);
01636 }; //InitObjBound
01637 
01638 
01650 class InitObjectiveBounds {
01651 
01652 public:
01654         int numberOfObj;
01655 
01657         InitObjBound **obj;
01658 
01663         InitObjectiveBounds();
01668         ~InitObjectiveBounds();
01669 
01674         bool IsEqual(InitObjectiveBounds *that);
01681         bool setObj(int numberOfObj, InitObjBound **obj);
01689         bool addObj(int idx, double lbValue, double ubValue);
01690 }; //InitObjectiveBounds
01691 
01692 
01704 class OtherObjOption {
01705 
01706 public:
01708         int idx;
01709 
01711         std::string value;
01712 
01713 
01715         std::string lbValue;
01716 
01718         std::string ubValue;
01723         OtherObjOption();
01728         ~OtherObjOption();
01729 
01734         bool IsEqual(OtherObjOption *that);
01735 }; //OtherObjOption
01736 
01737 
01749 class OtherObjectiveOption {
01750 
01751 public:
01753         int numberOfObj;
01754 
01756         std::string name;
01757 
01759         std::string value;
01760 
01762         std::string solver;
01763 
01765         std::string category;
01766 
01768         std::string type;
01769 
01771         std::string description;
01772 
01774         OtherObjOption **obj;
01775 
01780         OtherObjectiveOption();
01785         ~OtherObjectiveOption();
01786 
01791         bool IsEqual(OtherObjectiveOption *that);
01798         bool setObj(int numberOfObj, OtherObjOption **obj);
01807         bool addObj(int idx, std::string value, std::string lbValue, std::string ubValue);
01808 }; //OtherObjectiveOption
01809 
01810 
01822 class ObjectiveOption {
01823 
01824 public:
01826         int numberOfOtherObjectiveOptions;
01827 
01829         InitObjectiveValues *initialObjectiveValues;
01830 
01832         InitObjectiveBounds *initialObjectiveBounds;
01833 
01835         OtherObjectiveOption **other;
01836 
01841         ObjectiveOption();
01846         ~ObjectiveOption();
01847 
01852         bool IsEqual(ObjectiveOption *that);
01859         bool setOther(int numberOfOptions, OtherObjectiveOption  **other);
01865         bool addOther(OtherObjectiveOption *other);
01866 }; //ObjectiveOption
01867 
01868 
01880 class InitConValue {
01881 
01882 public:
01884         int idx;
01885 
01887         double value;
01888 
01893         InitConValue();
01898         ~InitConValue();
01899 
01904         bool IsEqual(InitConValue *that);
01905 }; //InitConValue
01906 
01907 
01919 class InitConstraintValues {
01920 
01921 public:
01923         int numberOfCon;
01924 
01926         InitConValue **con;
01927 
01932         InitConstraintValues();
01937         ~InitConstraintValues();
01938 
01943         bool IsEqual(InitConstraintValues *that);
01950         bool setCon(int numberOfCon, InitConValue **con);
01957         bool addCon(int idx, double value);
01958 }; //InitConstraintValues
01959 
01960 
01972 class InitDualVarValue {
01973 
01974 public:
01976         int idx;
01977 
01979         double lbDualValue;
01980 
01982         double ubDualValue;
01983 
01988         InitDualVarValue();
01993         ~InitDualVarValue();
01994 
01999         bool IsEqual(InitDualVarValue *that);
02000 }; //InitDualVarValue
02001 
02002 
02014 class InitDualVariableValues {
02015 
02016 public:
02018         int numberOfCon;
02019 
02021         InitDualVarValue **con;
02022 
02027         InitDualVariableValues();
02032         ~InitDualVariableValues();
02033 
02038         bool IsEqual(InitDualVariableValues *that);
02045         bool setCon(int numberOfCon, InitDualVarValue **con);
02053         bool addCon(int idx, double lbDualValue, double ubDualValue);
02054 }; //InitDualVariableValues
02055 
02056 
02068 class OtherConOption {
02069 
02070 public:
02072         int idx;
02073 
02075         std::string value;
02076 
02078         std::string lbValue;
02079 
02081         std::string ubValue;
02082 
02087         OtherConOption();
02092         ~OtherConOption();
02093 
02098         bool IsEqual(OtherConOption *that);
02099 }; //OtherConOption
02100 
02101 
02113 class OtherConstraintOption {
02114 
02115 public:
02117         int numberOfCon;
02118 
02120         std::string name;
02121 
02123         std::string value;
02124 
02126         std::string solver;
02127 
02129         std::string category;
02130 
02132         std::string type;
02133 
02135         std::string description;
02136 
02138         OtherConOption **con;
02139 
02144         OtherConstraintOption();
02149         ~OtherConstraintOption();
02150 
02155         bool IsEqual(OtherConstraintOption *that);
02162         bool setCon(int numberOfCon, OtherConOption **con);
02171         bool addCon(int idx, std::string value, std::string lbValue, std::string ubValue);
02172 }; //OtherConstraintOption
02173 
02174 
02186 class ConstraintOption {
02187 
02188 public:
02190         int numberOfOtherConstraintOptions;
02191 
02193         InitConstraintValues *initialConstraintValues;
02194 
02196         InitDualVariableValues *initialDualValues;
02197 
02199         OtherConstraintOption **other;
02200 
02205         ConstraintOption();
02210         ~ConstraintOption();
02211 
02216         bool IsEqual(ConstraintOption *that);
02223         bool setOther(int numberOfOptions, OtherConstraintOption  **other);
02229         bool addOther(OtherConstraintOption *other);
02230 }; //ConstraintOption
02231 
02232 
02244 class SolverOption {
02245 
02246 public:
02248         std::string name;
02249 
02251         std::string value;
02252 
02254         std::string solver;
02255 
02257         std::string category;
02258 
02260         std::string type;
02261 
02263         std::string description;
02264 
02269         SolverOption();
02274         ~SolverOption();
02275 
02280         bool IsEqual(SolverOption *that);
02281 }; //SolverOption
02282 
02283 
02295 class SolverOptions {
02296 
02297 public:
02299         int numberOfSolverOptions;
02300 
02302         SolverOption **solverOption;
02303 
02308         SolverOptions();
02313         ~SolverOptions();
02314 
02319         bool IsEqual(SolverOptions *that);
02320 
02327         bool setSolverOptions(int numberOfOptions, SolverOption **solverOption);
02328 
02339         bool addSolverOption(std::string name, std::string value, std::string solver, 
02340                  std::string category, std::string type, std::string description);
02341 }; //SolverOptions
02342 
02343 
02355 class OptimizationOption {
02356 
02357 public:
02359         int numberOfVariables;
02360 
02362         int numberOfObjectives;
02363 
02365         int numberOfConstraints;
02366 
02368         VariableOption *variables;
02369 
02371         ObjectiveOption *objectives;
02372 
02374         ConstraintOption *constraints;
02375 
02377         SolverOptions *solverOptions;
02382         OptimizationOption();
02387         ~OptimizationOption();
02388 
02393         bool IsEqual(OptimizationOption *that);
02394 }; //OptimizationOption
02395 
02396 
02407 class OSOption{
02408 
02409 public:
02410 
02416         GeneralOption *general;
02420         SystemOption *system;
02424         ServiceOption *service;
02428         JobOption *job;
02432         OptimizationOption *optimization;
02433 
02438         OSOption(); 
02443         ~OSOption();
02444 
02445 private:
02449         double* m_mdInitVarValuesDense;
02450 
02454         std::string* m_mdInitVarValuesStringDense;
02455 
02459         std::string* m_mdInitBasisStatusDense;
02460 
02464         double* m_mdIntegerVariableBranchingWeightsDense;
02465 
02469         double* m_mdInitObjValuesDense;
02470 
02474         double* m_mdInitObjLowerBoundsDense;
02475 
02479         double* m_mdInitObjUpperBoundsDense;
02480 
02484         double* m_mdInitConValuesDense;
02485 
02490         double* m_mdInitDualVarLowerBoundsDense;
02491 
02496         double* m_mdInitDualVarUpperBoundsDense;
02497 
02498 public:
02503         bool IsEqual(OSOption *that);
02504 
02505 public: 
02506         
02507         // get() methods...
02508         
02512         std::string  getServiceURI();
02513 
02517         std::string  getServiceName();
02518 
02522         std::string  getInstanceName();
02523 
02527         std::string  getInstanceLocation();
02528 
02532         std::string  getInstanceLocationType();
02533 
02537         std::string  getJobID();
02538 
02542         std::string  getSolverToInvoke();
02543 
02547         std::string  getLicense();
02548 
02552         std::string  getUserName();
02553 
02557         std::string  getPassword();
02558 
02562         std::string  getContact();
02563 
02567         std::string  getContactTransportType();
02568 
02572         std::string  getMinDiskSpaceUnit();
02573 
02577         std::string  getMinMemoryUnit();
02578 
02582         std::string  getMinCPUSpeedUnit();
02583 
02587         std::string  getServiceType();
02588 
02592         std::string  getMaxTimeUnit();
02593 
02597         std::string  getRequestedStartTime();
02598 
02602         std::string  getOptionStr(std::string optionName);
02603 
02607         double  getMinDiskSpace();
02608 
02612         double  getMinMemorySize();
02613 
02617         double  getMinCPUSpeed();
02618 
02622         double  getMaxTime();
02623 
02627         double  getOptionDbl(std::string optionName);
02628 
02632         int  getMinCPUNumber();
02633 
02637         int  getNumberOfOtherGeneralOptions();
02638 
02642         int  getNumberOfOtherSystemOptions();
02643 
02647         int  getNumberOfOtherServiceOptions();
02648 
02652         int  getNumberOfOtherJobOptions();
02653 
02657         int  getNumberOfJobDependencies();
02658 
02662         int  getNumberOfRequiredDirectories();
02663 
02667         int  getNumberOfRequiredFiles();
02668 
02672         int  getNumberOfDirectoriesToMake();
02673 
02677         int  getNumberOfFilesToMake();
02678 
02682         int  getNumberOfInputDirectoriesToMove();
02683 
02687         int  getNumberOfInputFilesToMove();
02688 
02692         int  getNumberOfOutputDirectoriesToMove();
02693 
02697         int  getNumberOfOutputFilesToMove();
02698 
02702         int  getNumberOfFilesToDelete();
02703 
02707         int  getNumberOfDirectoriesToDelete();
02708 
02712         int  getNumberOfProcessesToKill();
02713 
02717         int  getNumberOfVariables();
02718 
02722         int  getNumberOfObjectives();
02723 
02727         int  getNumberOfConstraints();
02728 
02734         int getNumberOfInitVarValues();
02735 
02741         int getNumberOfInitVarValuesString();
02742 
02748         int getNumberOfInitialBasisVariables();
02749 
02755         int getNumberOfIntegerVariableBranchingWeights();
02756 
02762         int getNumberOfSOS();
02763 
02769         int getNumberOfSOSVarBranchingWeights(int iSOS);
02770 
02776         int getNumberOfOtherVariableOptions();
02777         
02783         int getNumberOfInitObjValues();
02784 
02790         int getNumberOfInitObjBounds();
02791 
02797         int getNumberOfOtherObjectiveOptions();
02798         
02804         int getNumberOfInitConValues();
02805 
02811         int getNumberOfInitDualVarValues();
02812 
02818         int getNumberOfOtherConstraintOptions();
02819         
02825         int getNumberOfSolverOptions();
02826         
02830         int getOptionInt(std::string optionName);
02831 
02832 
02840         OtherOption** getOtherGeneralOptions();
02841 
02849         OtherOption** getOtherSystemOptions();
02850 
02858         OtherOption** getOtherServiceOptions();
02859 
02867         OtherOption** getOtherJobOptions();
02868 
02876         OtherOption** getOtherOptions(std::string elementName);
02877 
02885         OtherOption** getAllOtherOptions();
02886 
02893         std::string* getJobDependencies();
02894 
02902         std::string* getRequiredDirectories();
02903 
02911         std::string* getRequiredFiles();
02912 
02920         std::string* getDirectoriesToMake();
02921 
02929         std::string* getFilesToMake();
02930 
02938         PathPair** getInputDirectoriesToMove();
02939 
02947         PathPair** getInputFilesToMove();
02948 
02956         PathPair** getOutputDirectoriesToMove();
02957 
02965         PathPair** getOutputFilesToMove();
02966 
02974         std::string* getDirectoriesToDelete();
02975 
02983         std::string* getFilesToDelete();
02984 
02992         std::string* getProcessesToKill();
02993 
03001         InitVarValue** getInitVarValuesSparse();
03002 
03010         double* getInitVarValuesDense();
03011 
03020         double* getInitVarValuesDense(int numberOfVariables);
03021 
03029         InitVarValueString** getInitVarValuesStringSparse();
03030 
03038         std::string *getInitVarValuesStringDense();
03039 
03048         std::string *getInitVarValuesStringDense(int numberOfVariables);
03049 
03057         InitBasStatus** getInitBasisStatusSparse();
03058 
03066         std::string *getInitBasisStatusDense();
03067 
03076         std::string *getInitBasisStatusDense(int numberOfVariables);
03077 
03078 
03086         BranchingWeight**  getIntegerVariableBranchingWeightsSparse();
03087 
03095         double* getIntegerVariableBranchingWeightsDense();
03096 
03105         double* getIntegerVariableBranchingWeightsDense(int numberOfVariables);
03106 
03114         SOSWeights** getSOSVariableBranchingWeightsSparse(); 
03115 
03124         std::vector<OtherVariableOption*> getOtherVariableOptions(std::string solver_name);
03125 
03132         OtherVariableOption** getAllOtherVariableOptions();
03133 
03141         InitObjValue** getInitObjValuesSparse();
03142 
03150         double *getInitObjValuesDense();
03151 
03160         double *getInitObjValuesDense(int numberOfObjectives);
03161 
03169         InitObjBound** getInitObjBoundsSparse();
03170 
03178         double *getInitObjLowerBoundsDense();
03179 
03188         double *getInitObjLowerBoundsDense(int numberOfObjectives);
03189 
03197         double *getInitObjUpperBoundsDense();
03198 
03207         double *getInitObjUpperBoundsDense(int numberOfObjectives);
03208 
03216         std::vector<OtherObjectiveOption*> getOtherObjectiveOptions(std::string solver_name);
03217 
03224         OtherObjectiveOption** getAllOtherObjectiveOptions();
03225 
03233         InitConValue** getInitConValuesSparse();
03234 
03242         double *getInitConValuesDense();
03243 
03252         double *getInitConValuesDense(int numberOfConstraints);
03253 
03261         InitDualVarValue** getInitDualVarValuesSparse();
03262 
03270         double *getInitDualVarLowerBoundsDense();
03271 
03280         double *getInitDualVarLowerBoundsDense(int numberOfConstraints);
03281 
03282 
03290         double *getInitDualVarUpperBoundsDense();
03291 
03300         double *getInitDualVarUpperBoundsDense(int numberOfConstraints);
03301 
03309         std::vector<OtherConstraintOption*> getOtherConstraintOptions(std::string solver_name);
03310 
03311 
03318         OtherConstraintOption** getAllOtherConstraintOptions();
03319 
03328         std::vector<SolverOption*> getSolverOptions( std::string solver_name);
03329 
03336         SolverOption** getAllSolverOptions();
03337 
03338         /* --------------------------------------------------
03339  *  set() methods
03340  * -------------------------------------------------- */
03341 
03345         bool setServiceURI( std::string serviceURI);
03346 
03350         bool setServiceName( std::string serviceName);
03351 
03355         bool setInstanceName( std::string instanceName);
03356 
03360         bool setInstanceLocation( std::string instanceLocation);
03361 
03365         bool setInstanceLocationType( std::string locationType);
03366 
03370         bool setJobID( std::string jobID);
03371 
03375         bool setSolverToInvoke( std::string solverToInvoke);
03376 
03380         bool setLicense( std::string license);
03381 
03385         bool setUserName( std::string userName);
03386 
03390         bool setPassword( std::string password);
03391 
03395         bool setContact( std::string contact);
03396 
03400         bool setContactTransportType( std::string transportType);
03401 
03405         bool setOtherGeneralOptions(int numberOfOptions, OtherOption** other);
03406 
03410         bool setAnOtherGeneralOption(std::string name, std::string value, std::string description);
03411 
03412 
03413         bool setMinDiskSpace(double value);
03414 
03415         bool setMinDiskSpaceUnit(std::string unit);
03416 
03417         bool setMinMemorySize(double value);
03418 
03419         bool setMinMemoryUnit(std::string unit);
03420 
03421         bool setMinCPUSpeed(double value);
03422 
03423         bool setMinCPUSpeedUnit(std::string unit);
03424 
03425         bool setMinCPUNumber( int number);
03426 
03427         bool setOtherSystemOptions(int numberOfOptions, OtherOption** other);
03428 
03429         bool setAnOtherSystemOption(std::string name, std::string value, std::string description);
03430 
03431 
03432         bool setServiceType( std::string serviceType);
03433 
03434         bool setOtherServiceOptions(int numberOfOptions, OtherOption** other);
03435 
03436         bool setAnOtherServiceOption(std::string name, std::string value, std::string description);
03437 
03438 
03439         bool setMaxTime(double value);
03440 
03441         bool setMaxTimeUnit(std::string unit);
03442 
03443         bool setRequestedStartTime(std::string time);
03444 
03445         bool setJobDependencies(int numberOfDependencies, std::string* jobDependencies);
03446         bool setAnotherJobDependency(std::string jobID);
03447 
03448         bool setRequiredDirectories(int numberOfPaths, std::string* paths);
03449         bool setAnotherRequiredDirectory(std::string path);
03450 
03451         bool setRequiredFiles(int numberOfPaths, std::string* paths);
03452         bool setAnotherRequiredFile(std::string path);
03453 
03454         bool setDirectoriesToMake(int numberOfPaths, std::string* paths);
03455         bool setAnotherDirectoryToMake(std::string path);
03456 
03457         bool setFilesToMake(int numberOfPaths, std::string* paths);
03458         bool setAnotherFileToMake(std::string path);
03459 
03460         bool setInputDirectoriesToMove(int numberOfPathPairs, PathPair** pathPair);
03461         bool setAnotherInputDirectoryToMove(std::string fromPath, std::string toPath, bool makeCopy);
03462 
03463         bool setInputFilesToMove(int numberOfPathPairs, PathPair** pathPair);
03464         bool setAnotherInputFileToMove(std::string fromPath, std::string toPath, bool makeCopy);
03465 
03466         bool setOutputFilesToMove(int numberOfPathPairs, PathPair** pathPair);
03467         bool setAnotherOutputFileToMove(std::string fromPath, std::string toPath, bool makeCopy);
03468 
03469         bool setOutputDirectoriesToMove(int numberOfPathPairs, PathPair** pathPair);
03470         bool setAnotherOutputDirectoryToMove(std::string fromPath, std::string toPath, bool makeCopy);
03471 
03472         bool setFilesToDelete(int numberOfPaths, std::string* paths);
03473         bool setAnotherFileToDelete(std::string path);
03474 
03475         bool setDirectoriesToDelete(int numberOfPaths, std::string* paths);
03476         bool setAnotherDirectoryToDelete(std::string path);
03477 
03478         bool setProcessesToKill(int numberOfProcesses, std::string* processes);
03479         bool setAnotherProcessToKill(std::string process);
03480 
03481         bool setOtherJobOptions(int numberOfOptions, OtherOption** other);
03482         bool setAnOtherJobOption(std::string name, std::string value, std::string description);
03483 
03484 
03485         bool setNumberOfVariables(int numberOfObjects);
03486 
03487         bool setNumberOfObjectives(int numberOfObjects);
03488 
03489         bool setNumberOfConstraints(int numberOfObjects);
03490 
03491         bool setInitVarValuesSparse(int numberOfVar, InitVarValue** var);
03492         bool setInitVarValuesDense(int numberOfVar, double *value);
03493         bool setAnotherInitVarValue(int idx, double value);
03494 
03495         bool setInitVarValuesStringSparse(int numberOfVar, InitVarValueString** var);
03496         bool setInitVarValuesStringDense(int numberOfVar, std::string *value);
03497         bool setAnotherInitVarValueString(int idx, std::string value);
03498 
03499         bool setInitBasisStatusSparse(int numberOfVar, InitBasStatus** var);
03500         bool setInitBasisStatusDense(int numberOfVar, std::string *var);
03501         bool setAnotherInitBasisStatus(int idx, std::string value);
03502 
03503         bool setIntegerVariableBranchingWeightsSparse(int numberOfVar, BranchingWeight** var);
03504         bool setIntegerVariableBranchingWeightsDense(int numberOfVar, double *value);
03505         bool setAnotherIntegerVariableBranchingWeight(int idx, double value);
03506 
03507         bool setSOSVariableBranchingWeights(int numberOfSOS, SOSWeights** sos);
03508         bool setAnotherSOSVariableBranchingWeight(int sosIdx, int nvar, double weight, int* idx, double* value);
03509 
03510         bool setOtherVariableOptions(int numberOfVar, OtherVariableOption** var);
03511         bool setAnOtherVariableOption(OtherVariableOption* varOption);
03512 
03513         bool setInitObjValuesSparse(int numberOfObj, InitObjValue** obj);
03514         bool setInitObjValuesDense(int numberOfObj, double *value);
03515         bool setAnotherInitObjValue(int idx, double value);
03516 
03517         bool setInitObjBoundsSparse(int numberOfObj, InitObjBound** obj);
03518         bool setInitObjBoundsDense(int numberOfObj, double *lb, double *ub);
03519         bool setAnotherInitObjBound(int idx, double lbValue, double ubValue);
03520 
03521         bool setOtherObjectiveOptions(int numberOfObj, OtherObjectiveOption** obj);
03522         bool setAnOtherObjectiveOption(OtherObjectiveOption* objOption);
03523 
03524         bool setInitConValuesSparse(int numberOfCon, InitConValue** con);
03525         bool setInitConValuesDense(int numberOfCon, double *value);
03526         bool setAnotherInitConValue(int idx, double value);
03527 
03528         bool setInitDualVarValuesSparse(int numberOfCon, InitDualVarValue** con);
03529         bool setInitDualVarValuesDense(int numberOfCon, double *lb, double *ub);
03530         bool setAnotherInitDualVarValue(int idx, double lbValue, double ubValue);
03531 
03532         bool setOtherConstraintOptions(int numberOfOptions, OtherConstraintOption** other);
03533         bool setAnOtherConstraintOption(OtherConstraintOption* optionValue);
03534 
03535         bool setSolverOptions(int numberOfSolverOptions, SolverOption** solverOption);
03536         bool setAnotherSolverOption(std::string name, std::string value, std::string solver, 
03537                  std::string category, std::string type, std::string description);
03538 
03539         bool setOptionInt(std::string optionName, int optionValue);
03540 
03541         bool setOptionStr(std::string optionName, std::string optionValue);
03542 
03543         bool setOptionDbl(std::string optionName, double value);
03544 
03545 };//OSOption
03546 #endif

Generated on Tue Mar 30 03:04:39 2010 by  doxygen 1.4.7