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

Go to the documentation of this file.
00001 /* $Id: OSOption.h 4120 2011-03-30 06:28:16Z kmartin $ */
00016 #ifndef OSOPTION_H
00017 #define OSOPTION_H
00018 #include <string>
00019 #include <vector> 
00020 #include "OSGeneral.h"
00021 #include "OSMathUtil.h"
00022 
00023 
00024 //#define DEBUG
00025 
00026 
00038 class InstanceLocationOption {
00039 
00040 public:
00042         std::string locationType;
00043 
00045         std::string value;
00046 
00051         InstanceLocationOption();
00052 
00057         ~InstanceLocationOption();
00058 
00063         bool IsEqual(InstanceLocationOption *that);
00064 
00072         bool setRandom(double density, bool conformant);
00073 }; //InstanceLocationOption
00074 
00075 
00087 class ContactOption {
00088 
00089 public:
00091         std::string transportType;
00092 
00094         std::string value;
00095 
00100         ContactOption();
00105         ~ContactOption();
00106 
00111         bool IsEqual(ContactOption *that);
00112 
00120         bool setRandom(double density, bool conformant);
00121 }; //ContactOption
00122 
00123 
00135 class OtherOption {
00136 
00137 public:
00139         std::string name;
00140 
00142         std::string value;
00143 
00145         std::string description;
00146  
00151         OtherOption();
00156         ~OtherOption();
00157 
00162         bool IsEqual(OtherOption *that);
00163 
00171         bool setRandom(double density, bool conformant);
00172 }; //OtherOption
00173 
00174 
00186 class OtherOptions {
00187 
00188 public:
00190         int numberOfOtherOptions;
00191  
00193         OtherOption **other;
00194 
00199         OtherOptions();
00204         ~OtherOptions();
00205 
00210         bool IsEqual(OtherOptions *that);
00211 
00219         bool setRandom(double density, bool conformant);
00220 
00227         bool setOther(int numberOfOptions, OtherOption** other);
00228 
00236         bool addOther(std::string name, std::string value, std::string description);
00237 }; //OtherOptions
00238 
00239 
00251 class GeneralOption {
00252 
00253 public:
00254 
00256         std::string serviceURI;
00257         
00259         std::string serviceName;
00260 
00262         std::string instanceName;
00263 
00265         InstanceLocationOption *instanceLocation;
00266 
00268         std::string jobID;
00269 
00271         std::string solverToInvoke;
00272 
00274         std::string license;
00275 
00277         std::string userName;
00278 
00280         std::string password;
00281 
00283         ContactOption *contact;
00284 
00286         OtherOptions *otherOptions;
00287 
00292         GeneralOption();
00297         ~GeneralOption();               
00298 
00303         bool IsEqual(GeneralOption *that);
00304 
00312         bool setRandom(double density, bool conformant);
00313 };//GeneralOption
00314 
00328 class MinDiskSpace {
00329 
00330 public:
00332         std::string unit;
00333 
00335         std::string description;
00336 
00338         double value;
00339 
00340 
00345         MinDiskSpace();
00350         ~MinDiskSpace();
00351 
00356         bool IsEqual(MinDiskSpace *that);
00357 }; //MinDiskSpace
00358 
00372 class MinMemorySize {
00373 
00374 public:
00376         std::string unit;
00377 
00379         std::string description;
00380 
00382         double value;
00383 
00384 
00389         MinMemorySize();
00394         ~MinMemorySize();
00395 
00400         bool IsEqual(MinMemorySize *that);
00401 }; //MinMemorySize
00402 
00416 class MinCPUSpeed {
00417 
00418 public:
00420         std::string unit;
00421 
00423         std::string description;
00424 
00426         double value;
00427 
00428 
00433         MinCPUSpeed();
00438         ~MinCPUSpeed();
00439 
00444         bool IsEqual(MinCPUSpeed *that);
00445 }; //MinCPUSpeed
00446 
00460 class MinCPUNumber {
00461 
00462 public:
00464         std::string description;
00465 
00467         int value;
00468 
00469 
00474         MinCPUNumber();
00479         ~MinCPUNumber();
00480 
00485         bool IsEqual(MinCPUNumber *that);
00486 }; //MinCPUNumber
00487 
00488 
00500 class SystemOption {
00501 
00502 public:
00504         StorageCapacity *minDiskSpace;
00505 
00507         StorageCapacity *minMemorySize;
00508 
00510         CPUSpeed *minCPUSpeed;
00511 
00513         CPUNumber *minCPUNumber;
00514 
00516         OtherOptions *otherOptions;
00517 
00522         SystemOption();
00527         ~SystemOption();
00528 
00533         bool IsEqual(SystemOption *that);
00534 
00542         bool setRandom(double density, bool conformant);
00543 }; //SystemOption
00544 
00545 
00557 class ServiceOption {
00558 
00559 public:
00561         std::string type;
00562 
00564         OtherOptions *otherOptions;
00565 
00570         ServiceOption();
00575         ~ServiceOption();
00576 
00581         bool IsEqual(ServiceOption *that);
00582 
00590         bool setRandom(double density, bool conformant);
00591 }; //ServiceOption
00592 
00593 
00607 class MaxTime {
00608 
00609 public:
00611         std::string unit;
00612 
00614         double value;
00615 
00616 
00621         MaxTime();
00626         ~MaxTime();
00627 
00632         bool IsEqual(MaxTime *that);
00633 }; //MaxTime
00634 
00635 
00647 class JobDependencies {
00648 
00649 public:
00651         int numberOfJobIDs;
00652 
00654         std::string *jobID;
00655 
00660         JobDependencies();
00665         ~JobDependencies();
00666 
00671         bool IsEqual(JobDependencies *that);
00672 
00680         bool setRandom(double density, bool conformant);
00681 
00688         bool setJobID(int numberOfJobIDs, std::string *jobID);
00689 
00695         bool addJobID(std::string jobID);
00696 }; //JobDependencies
00697 
00698 
00710 class DirectoriesAndFiles {
00711 
00712 public:
00714         int numberOfPaths;
00715 
00717         std::string *path;
00718 
00723         DirectoriesAndFiles();
00728         ~DirectoriesAndFiles();
00729 
00734         bool IsEqual(DirectoriesAndFiles *that);
00735 
00743         bool setRandom(double density, bool conformant);
00744 
00751         bool setPath(int numberOfPaths, std::string *path);
00757         bool addPath(std::string path);
00758 }; //DirectoriesAndFiles
00759 
00760 
00761 
00773 class PathPair {
00774 
00775 public:
00777         std::string from;
00778 
00780         std::string to;
00781 
00783         bool makeCopy;
00784 
00789         PathPair();
00794         ~PathPair();
00795 
00800         bool IsEqual(PathPair *that);
00801 
00809         bool setRandom(double density, bool conformant);
00810 }; //PathPair
00811 
00812 
00824 class PathPairs {
00825 
00826 public:
00828         int numberOfPathPairs;
00829 
00831         PathPair **pathPair;
00832 
00837         PathPairs();
00842         ~PathPairs();
00843 
00848         bool IsEqual(PathPairs *that);
00849 
00857         bool setRandom(double density, bool conformant);
00858 
00865         bool setPathPair(int numberOfPathPairs, PathPair **pathPair);
00866 
00875         bool setPathPair(std::string *from, std::string *to, bool *makeCopy, int numberOfPathPairs);
00876 
00884         bool addPathPair(std::string fromPath, std::string toPath, bool makeCopy);
00885 }; //PathPairs
00886 
00887 
00899 class Processes {
00900 
00901 public:
00903         int numberOfProcesses;
00904 
00906         std::string *process;
00907 
00912         Processes();
00917         ~Processes();           
00918 
00923         bool IsEqual(Processes *that);
00924 
00932         bool setRandom(double density, bool conformant);
00933 
00940         bool setProcess(int numberOfProcesses, std::string *process);
00941 
00947         bool addProcess(std::string process);
00948 }; //Processes
00949 
00950 
00962 class JobOption {
00963 
00964 public:
00966         TimeSpan *maxTime;
00967 
00969         std::string requestedStartTime;
00970 
00972         JobDependencies *dependencies;
00973 
00975         DirectoriesAndFiles *requiredDirectories;
00976 
00978         DirectoriesAndFiles *requiredFiles;
00979 
00981         DirectoriesAndFiles *directoriesToMake;
00982 
00984         DirectoriesAndFiles *filesToMake;
00985 
00987         PathPairs *inputDirectoriesToMove;
00988 
00990         PathPairs *inputFilesToMove;
00991 
00993         PathPairs *outputFilesToMove;
00994 
00996         PathPairs *outputDirectoriesToMove;
00997 
00999         DirectoriesAndFiles *filesToDelete;
01000 
01002         DirectoriesAndFiles *directoriesToDelete;
01003 
01005         Processes *processesToKill;
01006 
01008         OtherOptions *otherOptions;
01009 
01014         JobOption();
01019         ~JobOption();   
01020 
01025         bool IsEqual(JobOption *that);
01026 
01034         bool setRandom(double density, bool conformant);
01035 }; //JobOption
01036 
01037 
01049 class InitVarValue {
01050 
01051 public:
01053         int idx;
01054 
01056         double value;
01057 
01062         InitVarValue();
01067         ~InitVarValue();
01068 
01073         bool IsEqual(InitVarValue *that);
01074 
01082         bool setRandom(double density, bool conformant);
01083 }; //InitVarValue
01084 
01085 
01097 class InitVariableValues {
01098 
01099 public:
01101         int numberOfVar;
01102 
01104         InitVarValue **var;
01105 
01110         InitVariableValues();
01115         ~InitVariableValues();
01116 
01121         bool IsEqual(InitVariableValues *that);
01122 
01130         bool setRandom(double density, bool conformant);
01131 
01138         bool setVar(int numberOfVar, InitVarValue **var);
01139 
01147         bool setVar(int numberOfVar, int *idx, double *value);
01148 
01155         bool addVar(int idx, double value);
01156 }; //InitVariableValues
01157 
01158 
01170 class InitVarValueString {
01171 
01172 public:
01174         int idx;
01175 
01177         std::string value;
01178 
01183         InitVarValueString();
01188         ~InitVarValueString();
01189 
01194         bool IsEqual(InitVarValueString *that);
01195 
01203         bool setRandom(double density, bool conformant);
01204 }; //InitVarValueString
01205 
01206 
01218 class InitVariableValuesString {
01219 
01220 public:
01222         int numberOfVar;
01223 
01225         InitVarValueString **var;
01226 
01231         InitVariableValuesString();
01236         ~InitVariableValuesString();
01237 
01242         bool IsEqual(InitVariableValuesString *that);
01243 
01251         bool setRandom(double density, bool conformant);
01252 
01259         bool setVar(int numberOfVar, InitVarValueString **var);
01260 
01268         bool setVar(int numberOfVar, int *idx, std::string *value);
01269 
01276         bool addVar(int idx, std::string value);
01277 }; //InitVariableValuesString
01278 
01291 class InitBasStatus {
01292 
01293 public:
01295         int idx;
01296 
01298         std::string value;
01299 
01304         InitBasStatus();
01309         ~InitBasStatus();               
01310 
01315         bool IsEqual(InitBasStatus *that);
01316 
01324         bool setRandom(double density, bool conformant);
01325 }; //InitBasStatus
01326 
01327 
01341 class InitialBasisStatus {
01342 
01343 public:
01345         int numberOfVar;
01346 
01348         InitBasStatus **var;
01349 
01354         InitialBasisStatus();
01359         ~InitialBasisStatus();
01360 
01365         bool IsEqual(InitialBasisStatus *that);
01366 
01374         bool setRandom(double density, bool conformant);
01375 
01382         bool setVar(int numberOfVar, InitBasStatus **var);
01383 
01390         bool addVar(int idx, std::string value);
01391 }; //InitialBasisStatus
01392 
01404 class BranchingWeight {
01405 
01406 public:
01408         int idx;
01409 
01411         double value;
01412 
01417         BranchingWeight();
01422         ~BranchingWeight();
01423 
01428         bool IsEqual(BranchingWeight *that);
01429 
01437         bool setRandom(double density, bool conformant);
01438 }; //BranchingWeight
01439 
01440 
01441 
01453 class IntegerVariableBranchingWeights {
01454 
01455 public:
01457         int numberOfVar;
01458 
01460         BranchingWeight **var;
01461 
01466         IntegerVariableBranchingWeights();
01471         ~IntegerVariableBranchingWeights();
01472 
01477         bool IsEqual(IntegerVariableBranchingWeights *that);
01478 
01486         bool setRandom(double density, bool conformant);
01487 
01494         bool setVar(int numberOfVar, BranchingWeight **var);
01495 
01503         bool setVar(int numberOfVar, int *idx, double *value);
01504 
01511         bool addVar(int idx, double value);
01512 }; //IntegerVariableBranchingWeights
01513 
01525 class SOSWeights {
01526 
01527 public:
01529         int sosIdx;
01530 
01532         double groupWeight;
01533 
01535         int numberOfVar;
01536 
01538         BranchingWeight **var;
01539 
01544         SOSWeights();
01549         ~SOSWeights();
01550 
01555         bool IsEqual(SOSWeights *that);
01556 
01564         bool setRandom(double density, bool conformant);
01565 
01572         bool setVar(int numberOfVar, BranchingWeight **var);
01573 
01580         bool addVar(int idx, double value);
01581 }; //SOSWeights
01582 
01583 
01595 class SOSVariableBranchingWeights {
01596 
01597 public:
01599         int numberOfSOS;
01600 
01602         SOSWeights **sos;
01603 
01608         SOSVariableBranchingWeights();
01613         ~SOSVariableBranchingWeights();
01614 
01619         bool IsEqual(SOSVariableBranchingWeights *that);
01620 
01628         bool setRandom(double density, bool conformant);
01629 
01637         bool setSOS(int numberOfSOS, SOSWeights **sos);
01647         bool addSOS(int sosIdx, int nvar, double weight, int* idx, double* value);
01648 }; //SOSVariableBranchingWeights
01649 
01661 class OtherVarOption {
01662 
01663 public:
01665         int idx;
01666 
01668         std::string value;
01669 
01671         std::string lbValue;
01672 
01674         std::string ubValue;
01675 
01680         OtherVarOption();
01685         ~OtherVarOption();
01686 
01691         bool IsEqual(OtherVarOption *that);
01692 
01700         bool setRandom(double density, bool conformant);
01701 }; //OtherVarOption
01702 
01703 
01712 class OtherVariableOption {
01713 
01714 public:
01716         int numberOfVar;
01717 
01719         int numberOfEnumerations;
01720 
01722         std::string name;
01723 
01725         std::string value;
01726 
01728         std::string solver;
01729 
01731         std::string category;
01732 
01734         std::string type;
01735 
01737         std::string description;
01738 
01740         OtherVarOption **var;
01741 
01742         /* a pointer to OtherOptionEnumeration objects that will
01743          * give for each distinct value the set of indices for 
01744          * this user defined variable result
01745          */
01746         OtherOptionEnumeration** enumeration;
01747 
01752         OtherVariableOption();
01757         ~OtherVariableOption(); 
01758 
01763         bool IsEqual(OtherVariableOption *that);
01764 
01772         bool setRandom(double density, bool conformant);
01773 
01780         bool setVar(int numberOfVar, OtherVarOption **var);
01781 
01790         bool addVar(int idx, std::string value, std::string lbValue, std::string ubValue);
01791 }; //OtherVariableOption
01792 
01793 
01805 class VariableOption {
01806 
01807 public:
01809         int numberOfOtherVariableOptions;
01810 
01812         InitVariableValues *initialVariableValues;
01813 
01815         InitVariableValuesString *initialVariableValuesString;
01816 
01818         BasisStatus *initialBasisStatus;
01819 
01821         IntegerVariableBranchingWeights *integerVariableBranchingWeights;
01822 
01824         SOSVariableBranchingWeights *sosVariableBranchingWeights;
01825 
01827         OtherVariableOption **other;
01828 
01833         VariableOption();
01838         ~VariableOption();
01839 
01844         bool IsEqual(VariableOption *that);
01845 
01853         bool setRandom(double density, bool conformant);
01854 
01861         bool setOther(int numberOfOptions, OtherVariableOption  **other);
01862 
01868         bool addOther(OtherVariableOption *other);
01869 }; //VariableOption
01870 
01871 
01883 class InitObjValue {
01884 
01885 public:
01887         int idx;
01888 
01890         double value;
01891 
01896         InitObjValue();
01901         ~InitObjValue();
01902 
01907         bool IsEqual(InitObjValue *that);
01908 
01916         bool setRandom(double density, bool conformant);
01917 }; //InitObjValue
01918 
01919 
01931 class InitObjectiveValues {
01932 
01933 public:
01935         int numberOfObj;
01936 
01938         InitObjValue **obj;
01939 
01944         InitObjectiveValues();
01949         ~InitObjectiveValues();
01950 
01955         bool IsEqual(InitObjectiveValues *that);
01956 
01964         bool setRandom(double density, bool conformant);
01965 
01972         bool setObj(int numberOfObj, InitObjValue **obj);
01973 
01981         bool setObj(int numberOfObj, int *idx, double *value);
01982 
01989         bool addObj(int idx, double value);
01990 }; //InitObjectiveValues
01991 
01992 
02004 class InitObjBound {
02005 
02006 public:
02008         int idx;
02009 
02011         double lbValue;
02012 
02014         double ubValue;
02015 
02020         InitObjBound();
02025         ~InitObjBound();
02026 
02031         bool IsEqual(InitObjBound *that);
02032 
02040         bool setRandom(double density, bool conformant);
02041 }; //InitObjBound
02042 
02043 
02055 class InitObjectiveBounds {
02056 
02057 public:
02059         int numberOfObj;
02060 
02062         InitObjBound **obj;
02063 
02068         InitObjectiveBounds();
02073         ~InitObjectiveBounds();
02074 
02079         bool IsEqual(InitObjectiveBounds *that);
02080 
02088         bool setRandom(double density, bool conformant);
02089 
02096         bool setObj(int numberOfObj, InitObjBound **obj);
02097 
02106         bool setObj(int numberOfObj, int *idx, double *lbValue, double *ubValue);
02107 
02115         bool addObj(int idx, double lbValue, double ubValue);
02116 }; //InitObjectiveBounds
02117 
02118 
02130 class OtherObjOption {
02131 
02132 public:
02134         int idx;
02135 
02137         std::string value;
02138 
02139 
02141         std::string lbValue;
02142 
02144         std::string ubValue;
02149         OtherObjOption();
02154         ~OtherObjOption();
02155 
02160         bool IsEqual(OtherObjOption *that);
02161 
02169         bool setRandom(double density, bool conformant);
02170 }; //OtherObjOption
02171 
02172 
02184 class OtherObjectiveOption {
02185 
02186 public:
02188         int numberOfObj;
02189 
02191         int numberOfEnumerations;
02192 
02194         std::string name;
02195 
02197         std::string value;
02198 
02200         std::string solver;
02201 
02203         std::string category;
02204 
02206         std::string type;
02207 
02209         std::string description;
02210 
02212         OtherObjOption **obj;
02213 
02214         /* a pointer to OtherOptionEnumeration objects that will
02215          * give for each distinct value the set of indices for 
02216          * this user defined variable result
02217          */
02218         OtherOptionEnumeration** enumeration;
02219 
02224         OtherObjectiveOption();
02229         ~OtherObjectiveOption();
02230 
02235         bool IsEqual(OtherObjectiveOption *that);
02236 
02244         bool setRandom(double density, bool conformant);
02245 
02252         bool setObj(int numberOfObj, OtherObjOption **obj);
02253 
02262         bool addObj(int idx, std::string value, std::string lbValue, std::string ubValue);
02263 }; //OtherObjectiveOption
02264 
02265 
02277 class ObjectiveOption {
02278 
02279 public:
02281         int numberOfOtherObjectiveOptions;
02282 
02284         InitObjectiveValues *initialObjectiveValues;
02285 
02287         InitObjectiveBounds *initialObjectiveBounds;
02288 
02290         BasisStatus *initialBasisStatus;
02291 
02293         OtherObjectiveOption **other;
02294 
02299         ObjectiveOption();
02304         ~ObjectiveOption();
02305 
02310         bool IsEqual(ObjectiveOption *that);
02311 
02319         bool setRandom(double density, bool conformant);
02320 
02327         bool setOther(int numberOfOptions, OtherObjectiveOption  **other);
02328 
02334         bool addOther(OtherObjectiveOption *other);
02335 }; //ObjectiveOption
02336 
02337 
02349 class InitConValue {
02350 
02351 public:
02353         int idx;
02354 
02356         double value;
02357 
02362         InitConValue();
02367         ~InitConValue();
02368 
02373         bool IsEqual(InitConValue *that);
02374 
02382         bool setRandom(double density, bool conformant);
02383 }; //InitConValue
02384 
02385 
02397 class InitConstraintValues {
02398 
02399 public:
02401         int numberOfCon;
02402 
02404         InitConValue **con;
02405 
02410         InitConstraintValues();
02415         ~InitConstraintValues();
02416 
02421         bool IsEqual(InitConstraintValues *that);
02422 
02430         bool setRandom(double density, bool conformant);
02431 
02438         bool setCon(int numberOfCon, InitConValue **con);
02439 
02447         bool setCon(int numberOfCon, int *idx, double *value);
02448 
02455         bool addCon(int idx, double value);
02456 }; //InitConstraintValues
02457 
02458 
02470 class InitDualVarValue {
02471 
02472 public:
02474         int idx;
02475 
02477         double lbDualValue;
02478 
02480         double ubDualValue;
02481 
02486         InitDualVarValue();
02487 
02492         ~InitDualVarValue();
02493 
02498         bool IsEqual(InitDualVarValue *that);
02499 
02507         bool setRandom(double density, bool conformant);
02508 }; //InitDualVarValue
02509 
02510 
02522 class InitDualVariableValues {
02523 
02524 public:
02526         int numberOfCon;
02527 
02529         InitDualVarValue **con;
02530 
02535         InitDualVariableValues();
02540         ~InitDualVariableValues();
02541 
02546         bool IsEqual(InitDualVariableValues *that);
02547 
02555         bool setRandom(double density, bool conformant);
02556 
02563         bool setCon(int numberOfCon, InitDualVarValue **con);
02564 
02573         bool setCon(int numberOfCon, int *idx, double *lbValue, double *ubValue);
02574 
02582         bool addCon(int idx, double lbDualValue, double ubDualValue);
02583 }; //InitDualVariableValues
02584 
02585 
02597 class OtherConOption {
02598 
02599 public:
02601         int idx;
02602 
02604         std::string value;
02605 
02607         std::string lbValue;
02608 
02610         std::string ubValue;
02611 
02616         OtherConOption();
02621         ~OtherConOption();
02622 
02627         bool IsEqual(OtherConOption *that);
02628 
02636         bool setRandom(double density, bool conformant);
02637 }; //OtherConOption
02638 
02639 
02651 class OtherConstraintOption {
02652 
02653 public:
02655         int numberOfCon;
02656 
02658         int numberOfEnumerations;
02659 
02661         std::string name;
02662 
02664         std::string value;
02665 
02667         std::string solver;
02668 
02670         std::string category;
02671 
02673         std::string type;
02674 
02676         std::string description;
02677 
02679         OtherConOption **con;
02680 
02681         /* a pointer to OtherOptionEnumeration objects that will
02682          * give for each distinct value the set of indices for 
02683          * this user defined variable result
02684          */
02685         OtherOptionEnumeration** enumeration;
02686 
02691         OtherConstraintOption();
02696         ~OtherConstraintOption();
02697 
02702         bool IsEqual(OtherConstraintOption *that);
02703         
02711         bool setRandom(double density, bool conformant);
02712 
02719         bool setCon(int numberOfCon, OtherConOption **con);
02720 
02729         bool addCon(int idx, std::string value, std::string lbValue, std::string ubValue);
02730 }; //OtherConstraintOption
02731 
02732 
02744 class ConstraintOption {
02745 
02746 public:
02748         int numberOfOtherConstraintOptions;
02749 
02751         InitConstraintValues *initialConstraintValues;
02752 
02754         InitDualVariableValues *initialDualValues;
02755 
02757         BasisStatus *initialBasisStatus;
02758 
02760         OtherConstraintOption **other;
02761 
02766         ConstraintOption();
02771         ~ConstraintOption();
02772 
02777         bool IsEqual(ConstraintOption *that);
02778 
02786         bool setRandom(double density, bool conformant);
02787 
02794         bool setOther(int numberOfOptions, OtherConstraintOption  **other);
02795 
02801         bool addOther(OtherConstraintOption *other);
02802 }; //ConstraintOption
02803 
02804 
02816 class SolverOption {
02817 
02818 public:
02820         std::string name;
02821 
02823         std::string value;
02824 
02826         std::string solver;
02827 
02829         std::string category;
02830 
02832         std::string type;
02833 
02835         std::string description;
02836 
02838         int numberOfItems;
02839 
02841         std::string* item;
02842 
02847         SolverOption();
02852         ~SolverOption();
02853 
02858         bool IsEqual(SolverOption *that);
02859 
02867         bool setRandom(double density, bool conformant);
02868 }; //SolverOption
02869 
02870 
02882 class SolverOptions {
02883 
02884 public:
02886         int numberOfSolverOptions;
02887 
02889         SolverOption **solverOption;
02890 
02895         SolverOptions();
02900         ~SolverOptions();
02901 
02906         bool IsEqual(SolverOptions *that);
02907 
02915         bool setRandom(double density, bool conformant);
02916 
02923         bool setSolverOptions(int numberOfOptions, SolverOption **solverOption);
02924 
02935         bool addSolverOption(std::string name, std::string value, std::string solver, 
02936                  std::string category, std::string type, std::string description);
02937 }; //SolverOptions
02938 
02939 
02951 class OptimizationOption {
02952 
02953 public:
02955         int numberOfVariables;
02956 
02958         int numberOfObjectives;
02959 
02961         int numberOfConstraints;
02962 
02964         VariableOption *variables;
02965 
02967         ObjectiveOption *objectives;
02968 
02970         ConstraintOption *constraints;
02971 
02973         SolverOptions *solverOptions;
02978         OptimizationOption();
02983         ~OptimizationOption();
02984 
02989         bool IsEqual(OptimizationOption *that);
02990 
02998         bool setRandom(double density, bool conformant);
02999 }; //OptimizationOption
03000 
03001 
03012 class OSOption{
03013 
03014 public:
03015 
03023         GeneralFileHeader *optionHeader;
03027         GeneralOption *general;
03031         SystemOption *system;
03035         ServiceOption *service;
03039         JobOption *job;
03043         OptimizationOption *optimization;
03044 
03049         OSOption(); 
03054         ~OSOption();
03055 
03065         bool setOptionHeader(std::string name, std::string source, 
03066                            std::string fileCreator, std::string description, std::string licence);
03067 
03068 private:
03072         double* m_mdInitVarValuesDense;
03073 
03077         std::string* m_mdInitVarValuesStringDense;
03078 
03082         int* m_mdInitBasisStatusDense;
03083 
03087         double* m_mdIntegerVariableBranchingWeightsDense;
03088 
03092         double* m_mdInitObjValuesDense;
03093 
03097         double* m_mdInitObjLowerBoundsDense;
03098 
03102         double* m_mdInitObjUpperBoundsDense;
03103 
03107         double* m_mdInitConValuesDense;
03108 
03113         double* m_mdInitDualVarLowerBoundsDense;
03114 
03119         double* m_mdInitDualVarUpperBoundsDense;
03120 
03121 public:
03126         bool IsEqual(OSOption *that);
03127 
03135         bool setRandom(double density, bool conformant);
03136 
03137 public: 
03138         
03139         // get() methods...
03140         
03144         std::string  getFileName();
03145 
03149         std::string  getFileSource();
03150 
03154         std::string  getFileDescription();
03155 
03159         std::string  getFileCreator();
03160 
03164         std::string  getFileLicence();
03165 
03169         std::string  getServiceURI();
03170 
03174         std::string  getServiceName();
03175 
03179         std::string  getInstanceName();
03180 
03184         std::string  getInstanceLocation();
03185 
03189         std::string  getInstanceLocationType();
03190 
03194         std::string  getJobID();
03195 
03199         std::string  getSolverToInvoke();
03200 
03204         std::string  getLicense();
03205 
03209         std::string  getUserName();
03210 
03214         std::string  getPassword();
03215 
03219         std::string  getContact();
03220 
03224         std::string  getContactTransportType();
03225 
03229         std::string  getMinDiskSpaceUnit();
03230 
03234         std::string  getMinDiskSpaceDescription();
03235 
03239         std::string  getMinMemoryUnit();
03240 
03244         std::string  getMinMemoryDescription();
03245 
03249         std::string  getMinCPUSpeedUnit();
03250 
03254         std::string  getMinCPUSpeedDescription();
03255 
03259         std::string  getMinCPUNumberDescription();
03260 
03264         std::string  getServiceType();
03265 
03269         std::string  getMaxTimeUnit();
03270 
03274         std::string  getRequestedStartTime();
03275 
03279         std::string  getOptionStr(std::string optionName);
03280 
03284         double  getMinDiskSpace();
03285 
03289         double  getMinMemorySize();
03290 
03294         double  getMinCPUSpeed();
03295 
03299         double  getMaxTime();
03300 
03304         double  getOptionDbl(std::string optionName);
03305 
03309         int  getMinCPUNumber();
03310 
03314         int  getNumberOfOtherGeneralOptions();
03315 
03319         int  getNumberOfOtherSystemOptions();
03320 
03324         int  getNumberOfOtherServiceOptions();
03325 
03329         int  getNumberOfOtherJobOptions();
03330 
03334         int  getNumberOfJobDependencies();
03335 
03339         int  getNumberOfRequiredDirectories();
03340 
03344         int  getNumberOfRequiredFiles();
03345 
03349         int  getNumberOfDirectoriesToMake();
03350 
03354         int  getNumberOfFilesToMake();
03355 
03359         int  getNumberOfInputDirectoriesToMove();
03360 
03364         int  getNumberOfInputFilesToMove();
03365 
03369         int  getNumberOfOutputDirectoriesToMove();
03370 
03374         int  getNumberOfOutputFilesToMove();
03375 
03379         int  getNumberOfFilesToDelete();
03380 
03384         int  getNumberOfDirectoriesToDelete();
03385 
03389         int  getNumberOfProcessesToKill();
03390 
03394         int  getNumberOfVariables();
03395 
03399         int  getNumberOfObjectives();
03400 
03404         int  getNumberOfConstraints();
03405 
03411         int getNumberOfInitVarValues();
03412 
03418         int getNumberOfInitVarValuesString();
03419 
03425         int getNumberOfIntegerVariableBranchingWeights();
03426 
03432         int getNumberOfSOS();
03433 
03439         int getNumberOfSOSVarBranchingWeights(int iSOS);
03440 
03446         int getNumberOfOtherVariableOptions();
03447         
03453         int getNumberOfInitObjValues();
03454 
03460         int getNumberOfInitObjBounds();
03461 
03467         int getNumberOfOtherObjectiveOptions();
03468         
03474         int getNumberOfInitConValues();
03475 
03481         int getNumberOfInitDualVarValues();
03482 
03488         int getNumberOfOtherConstraintOptions();
03489         
03495         int getNumberOfSolverOptions();
03496         
03500         int getOptionInt(std::string optionName);
03501 
03502 
03510         OtherOption** getOtherGeneralOptions();
03511 
03519         OtherOption** getOtherSystemOptions();
03520 
03528         OtherOption** getOtherServiceOptions();
03529 
03537         OtherOption** getOtherJobOptions();
03538 
03546         OtherOption** getOtherOptions(std::string elementName);
03547 
03555         OtherOption** getAllOtherOptions();
03556 
03563         std::string* getJobDependencies();
03564 
03572         std::string* getRequiredDirectories();
03573 
03581         std::string* getRequiredFiles();
03582 
03590         std::string* getDirectoriesToMake();
03591 
03599         std::string* getFilesToMake();
03600 
03608         PathPair** getInputDirectoriesToMove();
03609 
03617         PathPair** getInputFilesToMove();
03618 
03626         PathPair** getOutputDirectoriesToMove();
03627 
03635         PathPair** getOutputFilesToMove();
03636 
03644         std::string* getDirectoriesToDelete();
03645 
03653         std::string* getFilesToDelete();
03654 
03662         std::string* getProcessesToKill();
03663 
03671         InitVarValue** getInitVarValuesSparse();
03672 
03680         double* getInitVarValuesDense();
03681 
03690         double* getInitVarValuesDense(int numberOfVariables);
03691 
03699         InitVarValueString** getInitVarValuesStringSparse();
03700 
03708         std::string *getInitVarValuesStringDense();
03709 
03718         std::string *getInitVarValuesStringDense(int numberOfVariables);
03719 
03727         InitBasStatus** getInitBasisStatusSparse();
03728 
03736         std::string *getInitBasisStatusDense();
03737 
03746         int* getVariableInitialBasisStatusDense(int numberOfVariables);
03747 
03758         int getNumberOfInitialBasisElements(int type, int status);
03759 
03771         bool getInitialBasisElements(int type, int status, int* elem);
03772 
03780         BranchingWeight**  getIntegerVariableBranchingWeightsSparse();
03781 
03789         double* getIntegerVariableBranchingWeightsDense();
03790 
03799         double* getIntegerVariableBranchingWeightsDense(int numberOfVariables);
03800 
03808         SOSWeights** getSOSVariableBranchingWeightsSparse(); 
03809 
03818         std::vector<OtherVariableOption*> getOtherVariableOptions(std::string solver_name);
03819 
03826         OtherVariableOption** getAllOtherVariableOptions();
03827 
03835         InitObjValue** getInitObjValuesSparse();
03836 
03844         double *getInitObjValuesDense();
03845 
03854         double *getInitObjValuesDense(int numberOfObjectives);
03855 
03863         InitObjBound** getInitObjBoundsSparse();
03864 
03872         double *getInitObjLowerBoundsDense();
03873 
03882         double *getInitObjLowerBoundsDense(int numberOfObjectives);
03883 
03891         double *getInitObjUpperBoundsDense();
03892 
03901         double *getInitObjUpperBoundsDense(int numberOfObjectives);
03902 
03911         int* getObjectiveInitialBasisStatusDense(int numberOfObjectives);
03912 
03920         std::vector<OtherObjectiveOption*> getOtherObjectiveOptions(std::string solver_name);
03921 
03928         OtherObjectiveOption** getAllOtherObjectiveOptions();
03929 
03937         InitConValue** getInitConValuesSparse();
03938 
03946         double *getInitConValuesDense();
03947 
03956         double *getInitConValuesDense(int numberOfConstraints);
03957 
03965         InitDualVarValue** getInitDualVarValuesSparse();
03966 
03974         double *getInitDualVarLowerBoundsDense();
03975 
03984         double *getInitDualVarLowerBoundsDense(int numberOfConstraints);
03985 
03986 
03994         double *getInitDualVarUpperBoundsDense();
03995 
04004         double *getInitDualVarUpperBoundsDense(int numberOfConstraints);
04005 
04014         int* getSlackVariableInitialBasisStatusDense(int numberOfConstraints);
04015 
04023         std::vector<OtherConstraintOption*> getOtherConstraintOptions(std::string solver_name);
04024 
04025 
04032         OtherConstraintOption** getAllOtherConstraintOptions();
04033 
04042         std::vector<SolverOption*> getSolverOptions( std::string solver_name);
04043 
04050         SolverOption** getAllSolverOptions();
04051 
04052         /* --------------------------------------------------
04053  *  set() methods
04054  * -------------------------------------------------- */
04055 
04059         bool setServiceURI( std::string serviceURI);
04060 
04064         bool setServiceName( std::string serviceName);
04065 
04069         bool setInstanceName( std::string instanceName);
04070 
04074         bool setInstanceLocation( std::string instanceLocation);
04075 
04080         bool setInstanceLocation( std::string instanceLocation, std::string locationType);
04081 
04085         bool setInstanceLocationType( std::string locationType);
04086 
04090         bool setJobID( std::string jobID);
04091 
04095         bool setSolverToInvoke( std::string solverToInvoke);
04096 
04100         bool setLicense( std::string license);
04101 
04105         bool setUserName( std::string userName);
04106 
04110         bool setPassword( std::string password);
04111 
04115         bool setContact( std::string contact);
04116 
04121         bool setContact( std::string contact, std::string transportType);
04122 
04126         bool setContactTransportType( std::string transportType);
04127 
04131         bool setOtherGeneralOptions(int numberOfOptions, OtherOption** other);
04132 
04136         bool setAnOtherGeneralOption(std::string name, std::string value, std::string description);
04137 
04138         bool setMinDiskSpace(std::string unit, std::string description, double value);
04139 
04140         bool setMinDiskSpace(double value);
04141 
04142         bool setMinDiskSpaceUnit(std::string unit);
04143 
04144         bool setMinMemorySize(std::string unit, std::string description, double value);
04145 
04146         bool setMinMemorySize(double value);
04147 
04148         bool setMinMemoryUnit(std::string unit);
04149 
04150         bool setMinCPUSpeed(std::string unit, std::string description, double value);
04151 
04152         bool setMinCPUSpeed(double value);
04153 
04154         bool setMinCPUSpeedUnit(std::string unit);
04155 
04156         bool setMinCPUNumber( int number, std::string description);
04157 
04158         bool setMinCPUNumber( int number);
04159 
04160         bool setOtherSystemOptions(int numberOfOptions, OtherOption** other);
04161 
04162         bool setAnOtherSystemOption(std::string name, std::string value, std::string description);
04163 
04164 
04165         bool setServiceType( std::string serviceType);
04166 
04167         bool setOtherServiceOptions(int numberOfOptions, OtherOption** other);
04168 
04169         bool setAnOtherServiceOption(std::string name, std::string value, std::string description);
04170 
04171 
04172         bool setMaxTime(double value, std::string unit);
04173 
04174         bool setMaxTime(double value);
04175 
04176         bool setMaxTimeUnit(std::string unit);
04177 
04178         bool setRequestedStartTime(std::string time);
04179 
04180         bool setJobDependencies(int numberOfDependencies, std::string* jobDependencies);
04181         bool setAnotherJobDependency(std::string jobID);
04182 
04183         bool setRequiredDirectories(int numberOfPaths, std::string* paths);
04184         bool setAnotherRequiredDirectory(std::string path);
04185 
04186         bool setRequiredFiles(int numberOfPaths, std::string* paths);
04187         bool setAnotherRequiredFile(std::string path);
04188 
04189         bool setDirectoriesToMake(int numberOfPaths, std::string* paths);
04190         bool setAnotherDirectoryToMake(std::string path);
04191 
04192         bool setFilesToMake(int numberOfPaths, std::string* paths);
04193         bool setAnotherFileToMake(std::string path);
04194 
04212         bool setPathPairs(int object, std::string *from, std::string *to, bool *makeCopy, int numberOfPathPairs);
04213 
04214         bool setInputDirectoriesToMove(int numberOfPathPairs, PathPair** pathPair);
04215         bool setAnotherInputDirectoryToMove(std::string fromPath, std::string toPath, bool makeCopy);
04216 
04217         bool setInputFilesToMove(int numberOfPathPairs, PathPair** pathPair);
04218         bool setAnotherInputFileToMove(std::string fromPath, std::string toPath, bool makeCopy);
04219 
04220         bool setOutputFilesToMove(int numberOfPathPairs, PathPair** pathPair);
04221         bool setAnotherOutputFileToMove(std::string fromPath, std::string toPath, bool makeCopy);
04222 
04223         bool setOutputDirectoriesToMove(int numberOfPathPairs, PathPair** pathPair);
04224         bool setAnotherOutputDirectoryToMove(std::string fromPath, std::string toPath, bool makeCopy);
04225 
04226         bool setFilesToDelete(int numberOfPaths, std::string* paths);
04227         bool setAnotherFileToDelete(std::string path);
04228 
04229         bool setDirectoriesToDelete(int numberOfPaths, std::string* paths);
04230         bool setAnotherDirectoryToDelete(std::string path);
04231 
04232         bool setProcessesToKill(int numberOfProcesses, std::string* processes);
04233         bool setAnotherProcessToKill(std::string process);
04234 
04235         bool setOtherJobOptions(int numberOfOptions, OtherOption** other);
04236         bool setAnOtherJobOption(std::string name, std::string value, std::string description);
04237 
04238 
04239         bool setNumberOfVariables(int numberOfVariables);
04240 
04241         bool setNumberOfObjectives(int numberOfObjectives);
04242 
04243         bool setNumberOfConstraints(int numberOfConstraints);
04244 
04245         bool setInitVarValues(int numberOfVar, int* idx, double* value);
04246         bool setInitVarValuesSparse(int numberOfVar, InitVarValue** var);
04247         bool setInitVarValuesDense(int numberOfVar, double *value);
04248         bool setAnotherInitVarValue(int idx, double value);
04249 
04250         bool setInitVarValuesString(int numberOfVar, int* idx, std::string* value);
04251         bool setInitVarValuesStringSparse(int numberOfVar, InitVarValueString** var);
04252         bool setInitVarValuesStringDense(int numberOfVar, std::string *value);
04253         bool setAnotherInitVarValueString(int idx, std::string value);
04254 
04255         bool setInitBasisStatus(int object, int status, int *i, int ni);
04256         bool setInitBasisStatusSparse(int numberOfVar, InitBasStatus** var);
04257         bool setInitBasisStatusDense(int numberOfVar, std::string *var);
04258 
04267         bool setAnotherInitBasisStatus(int type, int idx, int status);
04268 
04269         bool setIntegerVariableBranchingWeights(int numberOfVar, int* idx, double* value);
04270         bool setIntegerVariableBranchingWeightsSparse(int numberOfVar, BranchingWeight** var);
04271         bool setIntegerVariableBranchingWeightsDense(int numberOfVar, double *value);
04272         bool setAnotherIntegerVariableBranchingWeight(int idx, double value);
04273 
04274         bool setSOSVariableBranchingWeights(int numberOfSOS, SOSWeights** sos);
04275         bool setAnotherSOSVariableBranchingWeight(int sosIdx, int nvar, double weight, int* idx, double* value);
04276  
04277         bool setNumberOfOtherVariableOptions(int numberOfOther);
04278         bool setOtherVariableOptions(int numberOfVar, OtherVariableOption** var);
04279         bool setAnOtherVariableOption(OtherVariableOption* varOption);
04280 
04294         bool setOtherVariableOptionAttributes(int iOther, int numberOfVar,
04295                                 int numberOfEnumerations, std::string name,
04296                                 std::string value, std::string solver,
04297                                 std::string category, std::string type,
04298                                 std::string description);
04299 
04300 
04313         bool setOtherOptionEnumeration(int object, int otherOptionNumber, int enumerationNumber,
04314                         int numberOfEl, std::string value, std::string description, int* idxArray);
04315 
04326         bool setOtherVariableOptionVar(int otherOptionNumber, int varNumber,
04327                         int idx, std::string value, std::string lbValue, std::string ubValue);
04328 
04329         bool setInitObjValues(int numberOfObj, int* idx, double* value);
04330         bool setInitObjValuesSparse(int numberOfObj, InitObjValue** obj);
04331         bool setInitObjValuesDense(int numberOfObj, double *value);
04332         bool setAnotherInitObjValue(int idx, double value);
04333 
04334         bool setInitObjBounds(int numberOfObj, int* idx, double* lbValue, double* ubValue);
04335         bool setInitObjBoundsSparse(int numberOfObj, InitObjBound** obj);
04336         bool setInitObjBoundsDense(int numberOfObj, double *lb, double *ub);
04337         bool setAnotherInitObjBound(int idx, double lbValue, double ubValue);
04338 
04339         bool setNumberOfOtherObjectiveOptions(int numberOfOther);
04340         bool setOtherObjectiveOptions(int numberOfObj, OtherObjectiveOption** obj);
04341         bool setAnOtherObjectiveOption(OtherObjectiveOption* objOption);
04342 
04356         bool setOtherObjectiveOptionAttributes(int iOther, int numberOfObj,
04357                                 int numberOfEnumerations, std::string name,
04358                                 std::string value, std::string solver,
04359                                 std::string category, std::string type,
04360                                 std::string description);
04361 
04362 
04373         bool setOtherObjectiveOptionObj(int otherOptionNumber, int objNumber,
04374                         int idx, std::string value, std::string lbValue, std::string ubValue);
04375 
04376         bool setInitConValues(int numberOfCon, int* idx, double* value);
04377         bool setInitConValuesSparse(int numberOfCon, InitConValue** con);
04378         bool setInitConValuesDense(int numberOfCon, double *value);
04379         bool setAnotherInitConValue(int idx, double value);
04380 
04381         bool setInitDualValues(int numberOfCon, int* idx, double* lbValue, double* ubValue);
04382         bool setInitDualVarValuesSparse(int numberOfCon, InitDualVarValue** con);
04383         bool setInitDualVarValuesDense(int numberOfCon, double *lb, double *ub);
04384         bool setAnotherInitDualVarValue(int idx, double lbValue, double ubValue);
04385 
04386         bool setNumberOfOtherConstraintOptions(int numberOfOther);
04387         bool setOtherConstraintOptions(int numberOfOptions, OtherConstraintOption** other);
04388         bool setAnOtherConstraintOption(OtherConstraintOption* optionValue);
04389 
04403         bool setOtherConstraintOptionAttributes(int iOther, int numberOfCon,
04404                                 int numberOfEnumerations, std::string name,
04405                                 std::string value, std::string solver,
04406                                 std::string category, std::string type,
04407                                 std::string description);
04408 
04409 
04420         bool setOtherConstraintOptionCon(int otherOptionNumber, int conNumber,
04421                         int idx, std::string value, std::string lbValue, std::string ubValue);
04422 
04423         bool setNumberOfSolverOptions(int numberOfOptions);
04424 
04438         bool setSolverOptionContent(int iOption, int numberOfItems,
04439                                 std::string name,
04440                                 std::string value, std::string solver,
04441                                 std::string category, std::string type,
04442                                 std::string description, std::string *itemList);
04443 
04444         bool setSolverOptions(int numberOfSolverOptions, SolverOption** solverOption);
04445         bool setAnotherSolverOption(std::string name, std::string value, std::string solver, 
04446                  std::string category, std::string type, std::string description);
04447 
04448 
04449         bool setOptionInt(std::string optionName, int optionValue);
04450 
04451         bool setOptionStr(std::string optionName, std::string optionValue);
04452 
04453         bool setOptionDbl(std::string optionName, double value);
04454 
04455 };//OSOption
04456 
04457 #endif

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