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

- File List
- File Members

# /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