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

Go to the documentation of this file.
00001 /* $Id: OSOption.h 4292 2011-09-21 05:47:18Z 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 
00041 public:
00043     std::string locationType;
00044 
00046     std::string value;
00047 
00052     InstanceLocationOption();
00053 
00058     ~InstanceLocationOption();
00059 
00064     bool IsEqual(InstanceLocationOption *that);
00065 
00073     bool setRandom(double density, bool conformant);
00074 }; //InstanceLocationOption
00075 
00076 
00088 class ContactOption
00089 {
00090 
00091 public:
00093     std::string transportType;
00094 
00096     std::string value;
00097 
00102     ContactOption();
00107     ~ContactOption();
00108 
00113     bool IsEqual(ContactOption *that);
00114 
00122     bool setRandom(double density, bool conformant);
00123 }; //ContactOption
00124 
00125 
00137 class OtherOption
00138 {
00139 
00140 public:
00142     std::string name;
00143 
00145     std::string value;
00146 
00148     std::string description;
00149 
00154     OtherOption();
00159     ~OtherOption();
00160 
00165     bool IsEqual(OtherOption *that);
00166 
00174     bool setRandom(double density, bool conformant);
00175 }; //OtherOption
00176 
00177 
00189 class OtherOptions
00190 {
00191 
00192 public:
00194     int numberOfOtherOptions;
00195 
00197     OtherOption **other;
00198 
00203     OtherOptions();
00208     ~OtherOptions();
00209 
00214     bool IsEqual(OtherOptions *that);
00215 
00223     bool setRandom(double density, bool conformant);
00224 
00231     bool setOther(int numberOfOptions, OtherOption** other);
00232 
00240     bool addOther(std::string name, std::string value, std::string description);
00241 }; //OtherOptions
00242 
00243 
00255 class GeneralOption
00256 {
00257 
00258 public:
00259 
00261     std::string serviceURI;
00262 
00264     std::string serviceName;
00265 
00267     std::string instanceName;
00268 
00270     InstanceLocationOption *instanceLocation;
00271 
00273     std::string jobID;
00274 
00276     std::string solverToInvoke;
00277 
00279     std::string license;
00280 
00282     std::string userName;
00283 
00285     std::string password;
00286 
00288     ContactOption *contact;
00289 
00291     OtherOptions *otherOptions;
00292 
00297     GeneralOption();
00302     ~GeneralOption();
00303 
00308     bool IsEqual(GeneralOption *that);
00309 
00317     bool setRandom(double density, bool conformant);
00318 };//GeneralOption
00319 
00333 class MinDiskSpace
00334 {
00335 
00336 public:
00338     std::string unit;
00339 
00341     std::string description;
00342 
00344     double value;
00345 
00346 
00351     MinDiskSpace();
00356     ~MinDiskSpace();
00357 
00362     bool IsEqual(MinDiskSpace *that);
00363 }; //MinDiskSpace
00364 
00378 class MinMemorySize
00379 {
00380 
00381 public:
00383     std::string unit;
00384 
00386     std::string description;
00387 
00389     double value;
00390 
00391 
00396     MinMemorySize();
00401     ~MinMemorySize();
00402 
00407     bool IsEqual(MinMemorySize *that);
00408 }; //MinMemorySize
00409 
00423 class MinCPUSpeed
00424 {
00425 
00426 public:
00428     std::string unit;
00429 
00431     std::string description;
00432 
00434     double value;
00435 
00436 
00441     MinCPUSpeed();
00446     ~MinCPUSpeed();
00447 
00452     bool IsEqual(MinCPUSpeed *that);
00453 }; //MinCPUSpeed
00454 
00468 class MinCPUNumber
00469 {
00470 
00471 public:
00473     std::string description;
00474 
00476     int value;
00477 
00478 
00483     MinCPUNumber();
00488     ~MinCPUNumber();
00489 
00494     bool IsEqual(MinCPUNumber *that);
00495 }; //MinCPUNumber
00496 
00497 
00509 class SystemOption
00510 {
00511 
00512 public:
00514     StorageCapacity *minDiskSpace;
00515 
00517     StorageCapacity *minMemorySize;
00518 
00520     CPUSpeed *minCPUSpeed;
00521 
00523     CPUNumber *minCPUNumber;
00524 
00526     OtherOptions *otherOptions;
00527 
00532     SystemOption();
00537     ~SystemOption();
00538 
00543     bool IsEqual(SystemOption *that);
00544 
00552     bool setRandom(double density, bool conformant);
00553 }; //SystemOption
00554 
00555 
00567 class ServiceOption
00568 {
00569 
00570 public:
00572     std::string type;
00573 
00575     OtherOptions *otherOptions;
00576 
00581     ServiceOption();
00586     ~ServiceOption();
00587 
00592     bool IsEqual(ServiceOption *that);
00593 
00601     bool setRandom(double density, bool conformant);
00602 }; //ServiceOption
00603 
00604 
00618 class MaxTime
00619 {
00620 
00621 public:
00623     std::string unit;
00624 
00626     double value;
00627 
00628 
00633     MaxTime();
00638     ~MaxTime();
00639 
00644     bool IsEqual(MaxTime *that);
00645 }; //MaxTime
00646 
00647 
00659 class JobDependencies
00660 {
00661 
00662 public:
00664     int numberOfJobIDs;
00665 
00667     std::string *jobID;
00668 
00673     JobDependencies();
00678     ~JobDependencies();
00679 
00684     bool IsEqual(JobDependencies *that);
00685 
00693     bool setRandom(double density, bool conformant);
00694 
00701     bool setJobID(int numberOfJobIDs, std::string *jobID);
00702 
00708     bool addJobID(std::string jobID);
00709 }; //JobDependencies
00710 
00711 
00723 class DirectoriesAndFiles
00724 {
00725 
00726 public:
00728     int numberOfPaths;
00729 
00731     std::string *path;
00732 
00737     DirectoriesAndFiles();
00742     ~DirectoriesAndFiles();
00743 
00748     bool IsEqual(DirectoriesAndFiles *that);
00749 
00757     bool setRandom(double density, bool conformant);
00758 
00765     bool setPath(int numberOfPaths, std::string *path);
00771     bool addPath(std::string path);
00772 }; //DirectoriesAndFiles
00773 
00774 
00775 
00787 class PathPair
00788 {
00789 
00790 public:
00792     std::string from;
00793 
00795     std::string to;
00796 
00798     bool makeCopy;
00799 
00804     PathPair();
00809     ~PathPair();
00810 
00815     bool IsEqual(PathPair *that);
00816 
00824     bool setRandom(double density, bool conformant);
00825 }; //PathPair
00826 
00827 
00839 class PathPairs
00840 {
00841 
00842 public:
00844     int numberOfPathPairs;
00845 
00847     PathPair **pathPair;
00848 
00853     PathPairs();
00858     ~PathPairs();
00859 
00864     bool IsEqual(PathPairs *that);
00865 
00873     bool setRandom(double density, bool conformant);
00874 
00881     bool setPathPair(int numberOfPathPairs, PathPair **pathPair);
00882 
00891     bool setPathPair(std::string *from, std::string *to, bool *makeCopy, int numberOfPathPairs);
00892 
00900     bool addPathPair(std::string fromPath, std::string toPath, bool makeCopy);
00901 }; //PathPairs
00902 
00903 
00915 class Processes
00916 {
00917 
00918 public:
00920     int numberOfProcesses;
00921 
00923     std::string *process;
00924 
00929     Processes();
00934     ~Processes();
00935 
00940     bool IsEqual(Processes *that);
00941 
00949     bool setRandom(double density, bool conformant);
00950 
00957     bool setProcess(int numberOfProcesses, std::string *process);
00958 
00964     bool addProcess(std::string process);
00965 }; //Processes
00966 
00967 
00979 class JobOption
00980 {
00981 
00982 public:
00984     TimeSpan *maxTime;
00985 
00987     std::string requestedStartTime;
00988 
00990     JobDependencies *dependencies;
00991 
00993     DirectoriesAndFiles *requiredDirectories;
00994 
00996     DirectoriesAndFiles *requiredFiles;
00997 
00999     DirectoriesAndFiles *directoriesToMake;
01000 
01002     DirectoriesAndFiles *filesToMake;
01003 
01005     PathPairs *inputDirectoriesToMove;
01006 
01008     PathPairs *inputFilesToMove;
01009 
01011     PathPairs *outputFilesToMove;
01012 
01014     PathPairs *outputDirectoriesToMove;
01015 
01017     DirectoriesAndFiles *filesToDelete;
01018 
01020     DirectoriesAndFiles *directoriesToDelete;
01021 
01023     Processes *processesToKill;
01024 
01026     OtherOptions *otherOptions;
01027 
01032     JobOption();
01037     ~JobOption();
01038 
01043     bool IsEqual(JobOption *that);
01044 
01052     bool setRandom(double density, bool conformant);
01053 }; //JobOption
01054 
01055 
01067 class InitVarValue
01068 {
01069 
01070 public:
01072     int idx;
01073 
01075     std::string name;
01076 
01078     double value;
01079 
01084     InitVarValue();
01089     ~InitVarValue();
01090 
01095     bool IsEqual(InitVarValue *that);
01096 
01104     bool setRandom(double density, bool conformant);
01105 }; //InitVarValue
01106 
01107 
01119 class InitVariableValues
01120 {
01121 
01122 public:
01124     int numberOfVar;
01125 
01127     InitVarValue **var;
01128 
01133     InitVariableValues();
01138     ~InitVariableValues();
01139 
01144     bool IsEqual(InitVariableValues *that);
01145 
01153     bool setRandom(double density, bool conformant);
01154 
01161     bool setVar(int numberOfVar, InitVarValue **var);
01162 
01171     bool setVar(int numberOfVar, int *idx, double *value, std::string *name);
01172 
01179     bool addVar(int idx, double value);
01180 }; //InitVariableValues
01181 
01182 
01194 class InitVarValueString
01195 {
01196 
01197 public:
01199     int idx;
01200 
01202     std::string name;
01203 
01205     std::string value;
01206 
01211     InitVarValueString();
01216     ~InitVarValueString();
01217 
01222     bool IsEqual(InitVarValueString *that);
01223 
01231     bool setRandom(double density, bool conformant);
01232 }; //InitVarValueString
01233 
01234 
01246 class InitVariableValuesString
01247 {
01248 
01249 public:
01251     int numberOfVar;
01252 
01254     InitVarValueString **var;
01255 
01260     InitVariableValuesString();
01265     ~InitVariableValuesString();
01266 
01271     bool IsEqual(InitVariableValuesString *that);
01272 
01280     bool setRandom(double density, bool conformant);
01281 
01288     bool setVar(int numberOfVar, InitVarValueString **var);
01289 
01298     bool setVar(int numberOfVar, int *idx, std::string *value, std::string* name);
01299 
01306     bool addVar(int idx, std::string value);
01307 }; //InitVariableValuesString
01308 
01321 class InitBasStatus
01322 {
01323 
01324 public:
01326     int idx;
01327 
01329     std::string value;
01330 
01335     InitBasStatus();
01340     ~InitBasStatus();
01341 
01346     bool IsEqual(InitBasStatus *that);
01347 
01355     bool setRandom(double density, bool conformant);
01356 }; //InitBasStatus
01357 
01358 
01372 class InitialBasisStatus
01373 {
01374 
01375 public:
01377     int numberOfVar;
01378 
01380     InitBasStatus **var;
01381 
01386     InitialBasisStatus();
01391     ~InitialBasisStatus();
01392 
01397     bool IsEqual(InitialBasisStatus *that);
01398 
01406     bool setRandom(double density, bool conformant);
01407 
01414     bool setVar(int numberOfVar, InitBasStatus **var);
01415 
01422     bool addVar(int idx, std::string value);
01423 }; //InitialBasisStatus
01424 
01436 class BranchingWeight
01437 {
01438 
01439 public:
01441     int idx;
01442 
01444     std::string name;
01445 
01447     double value;
01448 
01453     BranchingWeight();
01458     ~BranchingWeight();
01459 
01464     bool IsEqual(BranchingWeight *that);
01465 
01473     bool setRandom(double density, bool conformant);
01474 }; //BranchingWeight
01475 
01476 
01477 
01489 class IntegerVariableBranchingWeights
01490 {
01491 
01492 public:
01494     int numberOfVar;
01495 
01497     BranchingWeight **var;
01498 
01503     IntegerVariableBranchingWeights();
01508     ~IntegerVariableBranchingWeights();
01509 
01514     bool IsEqual(IntegerVariableBranchingWeights *that);
01515 
01523     bool setRandom(double density, bool conformant);
01524 
01531     bool setVar(int numberOfVar, BranchingWeight **var);
01532 
01541     bool setVar(int numberOfVar, int *idx, double *value, std::string* name);
01542 
01549     bool addVar(int idx, double value);
01550 }; //IntegerVariableBranchingWeights
01551 
01563 class SOSWeights
01564 {
01565 
01566 public:
01568     int sosIdx;
01569 
01571     double groupWeight;
01572 
01574     int numberOfVar;
01575 
01577     BranchingWeight **var;
01578 
01583     SOSWeights();
01588     ~SOSWeights();
01589 
01594     bool IsEqual(SOSWeights *that);
01595 
01603     bool setRandom(double density, bool conformant);
01604 
01611     bool setVar(int numberOfVar, BranchingWeight **var);
01612 
01619     bool addVar(int idx, double value);
01620 }; //SOSWeights
01621 
01622 
01634 class SOSVariableBranchingWeights
01635 {
01636 
01637 public:
01639     int numberOfSOS;
01640 
01642     SOSWeights **sos;
01643 
01648     SOSVariableBranchingWeights();
01653     ~SOSVariableBranchingWeights();
01654 
01659     bool IsEqual(SOSVariableBranchingWeights *that);
01660 
01668     bool setRandom(double density, bool conformant);
01669 
01677     bool setSOS(int numberOfSOS, SOSWeights **sos);
01687     bool addSOS(int sosIdx, int nvar, double weight, int* idx, double* value, std::string* name);
01688 }; //SOSVariableBranchingWeights
01689 
01701 class OtherVarOption
01702 {
01703 
01704 public:
01706     int idx;
01707 
01709     std::string name;
01710 
01712     std::string value;
01713 
01715     std::string lbValue;
01716 
01718     std::string ubValue;
01719 
01724     OtherVarOption();
01729     ~OtherVarOption();
01730 
01735     bool IsEqual(OtherVarOption *that);
01736 
01744     bool setRandom(double density, bool conformant);
01745 }; //OtherVarOption
01746 
01747 
01756 class OtherVariableOption
01757 {
01758 
01759 public:
01761     int numberOfVar;
01762 
01764     int numberOfEnumerations;
01765 
01767     std::string name;
01768 
01770     std::string value;
01771 
01773     std::string solver;
01774 
01776     std::string category;
01777 
01779     std::string type;
01780 
01782     std::string description;
01783 
01785     OtherVarOption **var;
01786 
01787     /* a pointer to OtherOptionEnumeration objects that will
01788      * give for each distinct value the set of indices for
01789      * this user defined variable result
01790      */
01791     OtherOptionEnumeration** enumeration;
01792 
01797     OtherVariableOption();
01802     ~OtherVariableOption();
01803 
01808     bool IsEqual(OtherVariableOption *that);
01809 
01817     bool setRandom(double density, bool conformant);
01818 
01825     bool setVar(int numberOfVar, OtherVarOption **var);
01826 
01835     bool addVar(int idx, std::string value, std::string lbValue, std::string ubValue);
01836 }; //OtherVariableOption
01837 
01838 
01850 class VariableOption
01851 {
01852 
01853 public:
01855     int numberOfOtherVariableOptions;
01856 
01858     InitVariableValues *initialVariableValues;
01859 
01861     InitVariableValuesString *initialVariableValuesString;
01862 
01864     BasisStatus *initialBasisStatus;
01865 
01867     IntegerVariableBranchingWeights *integerVariableBranchingWeights;
01868 
01870     SOSVariableBranchingWeights *sosVariableBranchingWeights;
01871 
01873     OtherVariableOption **other;
01874 
01879     VariableOption();
01884     ~VariableOption();
01885 
01890     bool IsEqual(VariableOption *that);
01891 
01899     bool setRandom(double density, bool conformant);
01900 
01907     bool setOther(int numberOfOptions, OtherVariableOption  **other);
01908 
01914     bool addOther(OtherVariableOption *other);
01915 }; //VariableOption
01916 
01917 
01929 class InitObjValue
01930 {
01931 
01932 public:
01934     int idx;
01935 
01937     std::string name;
01938 
01940     double value;
01941 
01946     InitObjValue();
01951     ~InitObjValue();
01952 
01957     bool IsEqual(InitObjValue *that);
01958 
01966     bool setRandom(double density, bool conformant);
01967 }; //InitObjValue
01968 
01969 
01981 class InitObjectiveValues
01982 {
01983 
01984 public:
01986     int numberOfObj;
01987 
01989     InitObjValue **obj;
01990 
01995     InitObjectiveValues();
02000     ~InitObjectiveValues();
02001 
02006     bool IsEqual(InitObjectiveValues *that);
02007 
02015     bool setRandom(double density, bool conformant);
02016 
02023     bool setObj(int numberOfObj, InitObjValue **obj);
02024 
02033     bool setObj(int numberOfObj, int *idx, double *value, std::string *name);
02034 
02041     bool addObj(int idx, double value);
02042 }; //InitObjectiveValues
02043 
02044 
02056 class InitObjBound
02057 {
02058 
02059 public:
02061     int idx;
02062 
02064     std::string name;
02065 
02067     double lbValue;
02068 
02070     double ubValue;
02071 
02076     InitObjBound();
02081     ~InitObjBound();
02082 
02087     bool IsEqual(InitObjBound *that);
02088 
02096     bool setRandom(double density, bool conformant);
02097 }; //InitObjBound
02098 
02099 
02111 class InitObjectiveBounds
02112 {
02113 
02114 public:
02116     int numberOfObj;
02117 
02119     InitObjBound **obj;
02120 
02125     InitObjectiveBounds();
02130     ~InitObjectiveBounds();
02131 
02136     bool IsEqual(InitObjectiveBounds *that);
02137 
02145     bool setRandom(double density, bool conformant);
02146 
02153     bool setObj(int numberOfObj, InitObjBound **obj);
02154 
02164     bool setObj(int numberOfObj, int *idx, double *lbValue, double *ubValue, std::string *name);
02165 
02173     bool addObj(int idx, double lbValue, double ubValue);
02174 }; //InitObjectiveBounds
02175 
02176 
02188 class OtherObjOption
02189 {
02190 
02191 public:
02193     int idx;
02194 
02196     std::string name;
02197 
02199     std::string value;
02200 
02201 
02203     std::string lbValue;
02204 
02206     std::string ubValue;
02211     OtherObjOption();
02216     ~OtherObjOption();
02217 
02222     bool IsEqual(OtherObjOption *that);
02223 
02231     bool setRandom(double density, bool conformant);
02232 }; //OtherObjOption
02233 
02234 
02246 class OtherObjectiveOption
02247 {
02248 
02249 public:
02251     int numberOfObj;
02252 
02254     int numberOfEnumerations;
02255 
02257     std::string name;
02258 
02260     std::string value;
02261 
02263     std::string solver;
02264 
02266     std::string category;
02267 
02269     std::string type;
02270 
02272     std::string description;
02273 
02275     OtherObjOption **obj;
02276 
02277     /* a pointer to OtherOptionEnumeration objects that will
02278      * give for each distinct value the set of indices for
02279      * this user defined variable result
02280      */
02281     OtherOptionEnumeration** enumeration;
02282 
02287     OtherObjectiveOption();
02292     ~OtherObjectiveOption();
02293 
02298     bool IsEqual(OtherObjectiveOption *that);
02299 
02307     bool setRandom(double density, bool conformant);
02308 
02315     bool setObj(int numberOfObj, OtherObjOption **obj);
02316 
02325     bool addObj(int idx, std::string value, std::string lbValue, std::string ubValue);
02326 }; //OtherObjectiveOption
02327 
02328 
02340 class ObjectiveOption
02341 {
02342 
02343 public:
02345     int numberOfOtherObjectiveOptions;
02346 
02348     InitObjectiveValues *initialObjectiveValues;
02349 
02351     InitObjectiveBounds *initialObjectiveBounds;
02352 
02354     BasisStatus *initialBasisStatus;
02355 
02357     OtherObjectiveOption **other;
02358 
02363     ObjectiveOption();
02368     ~ObjectiveOption();
02369 
02374     bool IsEqual(ObjectiveOption *that);
02375 
02383     bool setRandom(double density, bool conformant);
02384 
02391     bool setOther(int numberOfOptions, OtherObjectiveOption  **other);
02392 
02398     bool addOther(OtherObjectiveOption *other);
02399 }; //ObjectiveOption
02400 
02401 
02413 class InitConValue
02414 {
02415 
02416 public:
02418     int idx;
02419 
02421     std::string name;
02422 
02424     double value;
02425 
02430     InitConValue();
02435     ~InitConValue();
02436 
02441     bool IsEqual(InitConValue *that);
02442 
02450     bool setRandom(double density, bool conformant);
02451 }; //InitConValue
02452 
02453 
02465 class InitConstraintValues
02466 {
02467 
02468 public:
02470     int numberOfCon;
02471 
02473     InitConValue **con;
02474 
02479     InitConstraintValues();
02484     ~InitConstraintValues();
02485 
02490     bool IsEqual(InitConstraintValues *that);
02491 
02499     bool setRandom(double density, bool conformant);
02500 
02507     bool setCon(int numberOfCon, InitConValue **con);
02508 
02517     bool setCon(int numberOfCon, int *idx, double *value, std::string *name);
02518 
02525     bool addCon(int idx, double value);
02526 }; //InitConstraintValues
02527 
02528 
02540 class InitDualVarValue
02541 {
02542 
02543 public:
02545     int idx;
02546 
02548     std::string name;
02549 
02551     double lbDualValue;
02552 
02554     double ubDualValue;
02555 
02560     InitDualVarValue();
02561 
02566     ~InitDualVarValue();
02567 
02572     bool IsEqual(InitDualVarValue *that);
02573 
02581     bool setRandom(double density, bool conformant);
02582 }; //InitDualVarValue
02583 
02584 
02596 class InitDualVariableValues
02597 {
02598 
02599 public:
02601     int numberOfCon;
02602 
02604     InitDualVarValue **con;
02605 
02610     InitDualVariableValues();
02615     ~InitDualVariableValues();
02616 
02621     bool IsEqual(InitDualVariableValues *that);
02622 
02630     bool setRandom(double density, bool conformant);
02631 
02638     bool setCon(int numberOfCon, InitDualVarValue **con);
02639 
02649     bool setCon(int numberOfCon, int *idx, double *lbValue, double *ubValue, std::string *name);
02650 
02658     bool addCon(int idx, double lbDualValue, double ubDualValue);
02659 }; //InitDualVariableValues
02660 
02661 
02673 class OtherConOption
02674 {
02675 
02676 public:
02678     int idx;
02679 
02681     std::string name;
02682 
02684     std::string value;
02685 
02687     std::string lbValue;
02688 
02690     std::string ubValue;
02691 
02696     OtherConOption();
02701     ~OtherConOption();
02702 
02707     bool IsEqual(OtherConOption *that);
02708 
02716     bool setRandom(double density, bool conformant);
02717 }; //OtherConOption
02718 
02719 
02731 class OtherConstraintOption
02732 {
02733 
02734 public:
02736     int numberOfCon;
02737 
02739     int numberOfEnumerations;
02740 
02742     std::string name;
02743 
02745     std::string value;
02746 
02748     std::string solver;
02749 
02751     std::string category;
02752 
02754     std::string type;
02755 
02757     std::string description;
02758 
02760     OtherConOption **con;
02761 
02762     /* a pointer to OtherOptionEnumeration objects that will
02763      * give for each distinct value the set of indices for
02764      * this user defined variable result
02765      */
02766     OtherOptionEnumeration** enumeration;
02767 
02772     OtherConstraintOption();
02777     ~OtherConstraintOption();
02778 
02783     bool IsEqual(OtherConstraintOption *that);
02784 
02792     bool setRandom(double density, bool conformant);
02793 
02800     bool setCon(int numberOfCon, OtherConOption **con);
02801 
02810     bool addCon(int idx, std::string value, std::string lbValue, std::string ubValue);
02811 }; //OtherConstraintOption
02812 
02813 
02825 class ConstraintOption
02826 {
02827 
02828 public:
02830     int numberOfOtherConstraintOptions;
02831 
02833     InitConstraintValues *initialConstraintValues;
02834 
02836     InitDualVariableValues *initialDualValues;
02837 
02839     BasisStatus *initialBasisStatus;
02840 
02842     OtherConstraintOption **other;
02843 
02848     ConstraintOption();
02853     ~ConstraintOption();
02854 
02859     bool IsEqual(ConstraintOption *that);
02860 
02868     bool setRandom(double density, bool conformant);
02869 
02876     bool setOther(int numberOfOptions, OtherConstraintOption  **other);
02877 
02883     bool addOther(OtherConstraintOption *other);
02884 }; //ConstraintOption
02885 
02886 
02898 class SolverOption
02899 {
02900 
02901 public:
02903     std::string name;
02904 
02906     std::string value;
02907 
02909     std::string solver;
02910 
02912     std::string category;
02913 
02915     std::string type;
02916 
02918     std::string description;
02919 
02921     int numberOfItems;
02922 
02924     std::string* item;
02925 
02930     SolverOption();
02935     ~SolverOption();
02936 
02941     bool IsEqual(SolverOption *that);
02942 
02950     bool setRandom(double density, bool conformant);
02951 }; //SolverOption
02952 
02953 
02965 class SolverOptions
02966 {
02967 
02968 public:
02970     int numberOfSolverOptions;
02971 
02973     SolverOption **solverOption;
02974 
02979     SolverOptions();
02984     ~SolverOptions();
02985 
02990     bool IsEqual(SolverOptions *that);
02991 
02999     bool setRandom(double density, bool conformant);
03000 
03007     bool setSolverOptions(int numberOfOptions, SolverOption **solverOption);
03008 
03019     bool addSolverOption(std::string name, std::string value, std::string solver,
03020                          std::string category, std::string type, std::string description);
03021 }; //SolverOptions
03022 
03023 
03035 class OptimizationOption
03036 {
03037 
03038 public:
03040     int numberOfVariables;
03041 
03043     int numberOfObjectives;
03044 
03046     int numberOfConstraints;
03047 
03049     VariableOption *variables;
03050 
03052     ObjectiveOption *objectives;
03053 
03055     ConstraintOption *constraints;
03056 
03058     SolverOptions *solverOptions;
03063     OptimizationOption();
03068     ~OptimizationOption();
03069 
03074     bool IsEqual(OptimizationOption *that);
03075 
03083     bool setRandom(double density, bool conformant);
03084 }; //OptimizationOption
03085 
03086 
03097 class OSOption
03098 {
03099 
03100 public:
03101 
03109     GeneralFileHeader *optionHeader;
03113     GeneralOption *general;
03117     SystemOption *system;
03121     ServiceOption *service;
03125     JobOption *job;
03129     OptimizationOption *optimization;
03130 
03135     OSOption();
03140     ~OSOption();
03141 
03151     bool setOptionHeader(std::string name, std::string source,
03152                          std::string fileCreator, std::string description, std::string licence);
03153 
03154 private:
03158     double* m_mdInitVarValuesDense;
03159 
03163     std::string* m_mdInitVarValuesStringDense;
03164 
03168     int* m_mdInitBasisStatusDense;
03169 
03173     double* m_mdIntegerVariableBranchingWeightsDense;
03174 
03178     double* m_mdInitObjValuesDense;
03179 
03183     double* m_mdInitObjLowerBoundsDense;
03184 
03188     double* m_mdInitObjUpperBoundsDense;
03189 
03193     double* m_mdInitConValuesDense;
03194 
03199     double* m_mdInitDualVarLowerBoundsDense;
03200 
03205     double* m_mdInitDualVarUpperBoundsDense;
03206 
03207 public:
03212     bool IsEqual(OSOption *that);
03213 
03221     bool setRandom(double density, bool conformant);
03222 
03223 public:
03224 
03225     // get() methods...
03226 
03230     std::string  getFileName();
03231 
03235     std::string  getFileSource();
03236 
03240     std::string  getFileDescription();
03241 
03245     std::string  getFileCreator();
03246 
03250     std::string  getFileLicence();
03251 
03255     std::string  getServiceURI();
03256 
03260     std::string  getServiceName();
03261 
03265     std::string  getInstanceName();
03266 
03270     std::string  getInstanceLocation();
03271 
03275     std::string  getInstanceLocationType();
03276 
03280     std::string  getJobID();
03281 
03285     std::string  getSolverToInvoke();
03286 
03290     std::string  getLicense();
03291 
03295     std::string  getUserName();
03296 
03300     std::string  getPassword();
03301 
03305     std::string  getContact();
03306 
03310     std::string  getContactTransportType();
03311 
03315     std::string  getMinDiskSpaceUnit();
03316 
03320     std::string  getMinDiskSpaceDescription();
03321 
03325     std::string  getMinMemoryUnit();
03326 
03330     std::string  getMinMemoryDescription();
03331 
03335     std::string  getMinCPUSpeedUnit();
03336 
03340     std::string  getMinCPUSpeedDescription();
03341 
03345     std::string  getMinCPUNumberDescription();
03346 
03350     std::string  getServiceType();
03351 
03355     std::string  getMaxTimeUnit();
03356 
03360     std::string  getRequestedStartTime();
03361 
03365     std::string  getOptionStr(std::string optionName);
03366 
03370     double  getMinDiskSpace();
03371 
03375     double  getMinMemorySize();
03376 
03380     double  getMinCPUSpeed();
03381 
03385     double  getMaxTime();
03386 
03390     double  getOptionDbl(std::string optionName);
03391 
03395     int  getMinCPUNumber();
03396 
03400     int  getNumberOfOtherGeneralOptions();
03401 
03405     int  getNumberOfOtherSystemOptions();
03406 
03410     int  getNumberOfOtherServiceOptions();
03411 
03415     int  getNumberOfOtherJobOptions();
03416 
03420     int  getNumberOfJobDependencies();
03421 
03425     int  getNumberOfRequiredDirectories();
03426 
03430     int  getNumberOfRequiredFiles();
03431 
03435     int  getNumberOfDirectoriesToMake();
03436 
03440     int  getNumberOfFilesToMake();
03441 
03445     int  getNumberOfInputDirectoriesToMove();
03446 
03450     int  getNumberOfInputFilesToMove();
03451 
03455     int  getNumberOfOutputDirectoriesToMove();
03456 
03460     int  getNumberOfOutputFilesToMove();
03461 
03465     int  getNumberOfFilesToDelete();
03466 
03470     int  getNumberOfDirectoriesToDelete();
03471 
03475     int  getNumberOfProcessesToKill();
03476 
03480     int  getNumberOfVariables();
03481 
03485     int  getNumberOfObjectives();
03486 
03490     int  getNumberOfConstraints();
03491 
03497     int getNumberOfInitVarValues();
03498 
03504     int getNumberOfInitVarValuesString();
03505 
03511     int getNumberOfIntegerVariableBranchingWeights();
03512 
03518     int getNumberOfSOS();
03519 
03525     int getNumberOfSOSVarBranchingWeights(int iSOS);
03526 
03532     int getNumberOfOtherVariableOptions();
03533 
03539     int getNumberOfInitObjValues();
03540 
03546     int getNumberOfInitObjBounds();
03547 
03553     int getNumberOfOtherObjectiveOptions();
03554 
03560     int getNumberOfInitConValues();
03561 
03567     int getNumberOfInitDualVarValues();
03568 
03574     int getNumberOfOtherConstraintOptions();
03575 
03581     int getNumberOfSolverOptions();
03582 
03586     int getOptionInt(std::string optionName);
03587 
03588 
03596     OtherOption** getOtherGeneralOptions();
03597 
03605     OtherOption** getOtherSystemOptions();
03606 
03614     OtherOption** getOtherServiceOptions();
03615 
03623     OtherOption** getOtherJobOptions();
03624 
03632     OtherOption** getOtherOptions(std::string elementName);
03633 
03641     OtherOption** getAllOtherOptions();
03642 
03649     std::string* getJobDependencies();
03650 
03658     std::string* getRequiredDirectories();
03659 
03667     std::string* getRequiredFiles();
03668 
03676     std::string* getDirectoriesToMake();
03677 
03685     std::string* getFilesToMake();
03686 
03694     PathPair** getInputDirectoriesToMove();
03695 
03703     PathPair** getInputFilesToMove();
03704 
03712     PathPair** getOutputDirectoriesToMove();
03713 
03721     PathPair** getOutputFilesToMove();
03722 
03730     std::string* getDirectoriesToDelete();
03731 
03739     std::string* getFilesToDelete();
03740 
03748     std::string* getProcessesToKill();
03749 
03757     InitVarValue** getInitVarValuesSparse();
03758 
03766     double* getInitVarValuesDense();
03767 
03776     double* getInitVarValuesDense(int numberOfVariables);
03777 
03785     InitVarValueString** getInitVarValuesStringSparse();
03786 
03794     std::string *getInitVarValuesStringDense();
03795 
03804     std::string *getInitVarValuesStringDense(int numberOfVariables);
03805 
03813     InitBasStatus** getInitBasisStatusSparse();
03814 
03822     std::string *getInitBasisStatusDense();
03823 
03832     int* getVariableInitialBasisStatusDense(int numberOfVariables);
03833 
03844     int getNumberOfInitialBasisElements(int type, int status);
03845 
03857     bool getInitialBasisElements(int type, int status, int* elem);
03858 
03866     BranchingWeight**  getIntegerVariableBranchingWeightsSparse();
03867 
03875     double* getIntegerVariableBranchingWeightsDense();
03876 
03885     double* getIntegerVariableBranchingWeightsDense(int numberOfVariables);
03886 
03894     SOSWeights** getSOSVariableBranchingWeightsSparse();
03895 
03904     std::vector<OtherVariableOption*> getOtherVariableOptions(std::string solver_name);
03905 
03912     OtherVariableOption** getAllOtherVariableOptions();
03913 
03921     InitObjValue** getInitObjValuesSparse();
03922 
03930     double *getInitObjValuesDense();
03931 
03940     double *getInitObjValuesDense(int numberOfObjectives);
03941 
03949     InitObjBound** getInitObjBoundsSparse();
03950 
03958     double *getInitObjLowerBoundsDense();
03959 
03968     double *getInitObjLowerBoundsDense(int numberOfObjectives);
03969 
03977     double *getInitObjUpperBoundsDense();
03978 
03987     double *getInitObjUpperBoundsDense(int numberOfObjectives);
03988 
03997     int* getObjectiveInitialBasisStatusDense(int numberOfObjectives);
03998 
04006     std::vector<OtherObjectiveOption*> getOtherObjectiveOptions(std::string solver_name);
04007 
04014     OtherObjectiveOption** getAllOtherObjectiveOptions();
04015 
04023     InitConValue** getInitConValuesSparse();
04024 
04032     double *getInitConValuesDense();
04033 
04042     double *getInitConValuesDense(int numberOfConstraints);
04043 
04051     InitDualVarValue** getInitDualVarValuesSparse();
04052 
04060     double *getInitDualVarLowerBoundsDense();
04061 
04070     double *getInitDualVarLowerBoundsDense(int numberOfConstraints);
04071 
04072 
04080     double *getInitDualVarUpperBoundsDense();
04081 
04090     double *getInitDualVarUpperBoundsDense(int numberOfConstraints);
04091 
04100     int* getSlackVariableInitialBasisStatusDense(int numberOfConstraints);
04101 
04109     std::vector<OtherConstraintOption*> getOtherConstraintOptions(std::string solver_name);
04110 
04111 
04118     OtherConstraintOption** getAllOtherConstraintOptions();
04119 
04128     std::vector<SolverOption*> getSolverOptions( std::string solver_name);
04129 
04130 
04142     std::vector<SolverOption*> getSolverOptions( std::string solver_name, bool getFreeOptions);
04143 
04150     SolverOption** getAllSolverOptions();
04151 
04152     /* --------------------------------------------------
04153     *  set() methods
04154     * -------------------------------------------------- */
04155 
04159     bool setServiceURI( std::string serviceURI);
04160 
04164     bool setServiceName( std::string serviceName);
04165 
04169     bool setInstanceName( std::string instanceName);
04170 
04174     bool setInstanceLocation( std::string instanceLocation);
04175 
04180     bool setInstanceLocation( std::string instanceLocation, std::string locationType);
04181 
04185     bool setInstanceLocationType( std::string locationType);
04186 
04190     bool setJobID( std::string jobID);
04191 
04195     bool setSolverToInvoke( std::string solverToInvoke);
04196 
04200     bool setLicense( std::string license);
04201 
04205     bool setUserName( std::string userName);
04206 
04210     bool setPassword( std::string password);
04211 
04215     bool setContact( std::string contact);
04216 
04221     bool setContact( std::string contact, std::string transportType);
04222 
04226     bool setContactTransportType( std::string transportType);
04227 
04231     bool setOtherGeneralOptions(int numberOfOptions, OtherOption** other);
04232 
04236     bool setAnOtherGeneralOption(std::string name, std::string value, std::string description);
04237 
04238     bool setMinDiskSpace(std::string unit, std::string description, double value);
04239 
04240     bool setMinDiskSpace(double value);
04241 
04242     bool setMinDiskSpaceUnit(std::string unit);
04243 
04244     bool setMinMemorySize(std::string unit, std::string description, double value);
04245 
04246     bool setMinMemorySize(double value);
04247 
04248     bool setMinMemoryUnit(std::string unit);
04249 
04250     bool setMinCPUSpeed(std::string unit, std::string description, double value);
04251 
04252     bool setMinCPUSpeed(double value);
04253 
04254     bool setMinCPUSpeedUnit(std::string unit);
04255 
04256     bool setMinCPUNumber( int number, std::string description);
04257 
04258     bool setMinCPUNumber( int number);
04259 
04260     bool setOtherSystemOptions(int numberOfOptions, OtherOption** other);
04261 
04262     bool setAnOtherSystemOption(std::string name, std::string value, std::string description);
04263 
04264 
04265     bool setServiceType( std::string serviceType);
04266 
04267     bool setOtherServiceOptions(int numberOfOptions, OtherOption** other);
04268 
04269     bool setAnOtherServiceOption(std::string name, std::string value, std::string description);
04270 
04271 
04272     bool setMaxTime(double value, std::string unit);
04273 
04274     bool setMaxTime(double value);
04275 
04276     bool setMaxTimeUnit(std::string unit);
04277 
04278     bool setRequestedStartTime(std::string time);
04279 
04280     bool setJobDependencies(int numberOfDependencies, std::string* jobDependencies);
04281     bool setAnotherJobDependency(std::string jobID);
04282 
04283     bool setRequiredDirectories(int numberOfPaths, std::string* paths);
04284     bool setAnotherRequiredDirectory(std::string path);
04285 
04286     bool setRequiredFiles(int numberOfPaths, std::string* paths);
04287     bool setAnotherRequiredFile(std::string path);
04288 
04289     bool setDirectoriesToMake(int numberOfPaths, std::string* paths);
04290     bool setAnotherDirectoryToMake(std::string path);
04291 
04292     bool setFilesToMake(int numberOfPaths, std::string* paths);
04293     bool setAnotherFileToMake(std::string path);
04294 
04312     bool setPathPairs(int object, std::string *from, std::string *to, bool *makeCopy, int numberOfPathPairs);
04313 
04314     bool setInputDirectoriesToMove(int numberOfPathPairs, PathPair** pathPair);
04315     bool setAnotherInputDirectoryToMove(std::string fromPath, std::string toPath, bool makeCopy);
04316 
04317     bool setInputFilesToMove(int numberOfPathPairs, PathPair** pathPair);
04318     bool setAnotherInputFileToMove(std::string fromPath, std::string toPath, bool makeCopy);
04319 
04320     bool setOutputFilesToMove(int numberOfPathPairs, PathPair** pathPair);
04321     bool setAnotherOutputFileToMove(std::string fromPath, std::string toPath, bool makeCopy);
04322 
04323     bool setOutputDirectoriesToMove(int numberOfPathPairs, PathPair** pathPair);
04324     bool setAnotherOutputDirectoryToMove(std::string fromPath, std::string toPath, bool makeCopy);
04325 
04326     bool setFilesToDelete(int numberOfPaths, std::string* paths);
04327     bool setAnotherFileToDelete(std::string path);
04328 
04329     bool setDirectoriesToDelete(int numberOfPaths, std::string* paths);
04330     bool setAnotherDirectoryToDelete(std::string path);
04331 
04332     bool setProcessesToKill(int numberOfProcesses, std::string* processes);
04333     bool setAnotherProcessToKill(std::string process);
04334 
04335     bool setOtherJobOptions(int numberOfOptions, OtherOption** other);
04336     bool setAnOtherJobOption(std::string name, std::string value, std::string description);
04337 
04338 
04339     bool setNumberOfVariables(int numberOfVariables);
04340 
04341     bool setNumberOfObjectives(int numberOfObjectives);
04342 
04343     bool setNumberOfConstraints(int numberOfConstraints);
04344 
04345     bool setInitVarValues(int numberOfVar, int* idx, double* value, std::string* name);
04346     bool setInitVarValuesSparse(int numberOfVar, InitVarValue** var);
04347     bool setInitVarValuesDense(int numberOfVar, double *value);
04348     bool setAnotherInitVarValue(int idx, double value);
04349 
04350     bool setInitVarValuesString(int numberOfVar, int* idx, std::string* value, std::string* name);
04351     bool setInitVarValuesStringSparse(int numberOfVar, InitVarValueString** var);
04352     bool setInitVarValuesStringDense(int numberOfVar, std::string *value);
04353     bool setAnotherInitVarValueString(int idx, std::string value);
04354 
04355     bool setInitBasisStatus(int object, int status, int *i, int ni);
04356     bool setInitBasisStatusSparse(int numberOfVar, InitBasStatus** var);
04357     bool setInitBasisStatusDense(int numberOfVar, std::string *var);
04358 
04367     bool setAnotherInitBasisStatus(int type, int idx, int status);
04368 
04369     bool setIntegerVariableBranchingWeights(int numberOfVar, int* idx, double* value, std::string* name);
04370     bool setIntegerVariableBranchingWeightsSparse(int numberOfVar, BranchingWeight** var);
04371     bool setIntegerVariableBranchingWeightsDense(int numberOfVar, double *value);
04372     bool setAnotherIntegerVariableBranchingWeight(int idx, double value);
04373 
04374     bool setSOSVariableBranchingWeights(int numberOfSOS, SOSWeights** sos);
04375     bool setAnotherSOSVariableBranchingWeight(int sosIdx, int nvar, double weight, int* idx, double* value, std::string* name);
04376 
04377     bool setNumberOfOtherVariableOptions(int numberOfOther);
04378     bool setOtherVariableOptions(int numberOfVar, OtherVariableOption** var);
04379     bool setAnOtherVariableOption(OtherVariableOption* varOption);
04380 
04394     bool setOtherVariableOptionAttributes(int iOther, int numberOfVar,
04395                                           int numberOfEnumerations, std::string name,
04396                                           std::string value, std::string solver,
04397                                           std::string category, std::string type,
04398                                           std::string description);
04399 
04400 
04413     bool setOtherOptionEnumeration(int object, int otherOptionNumber, int enumerationNumber,
04414                                    int numberOfEl, std::string value, std::string description, int* idxArray);
04415 
04426     bool setOtherVariableOptionVar(int otherOptionNumber, int varNumber,
04427                                    int idx, std::string name, std::string value, std::string lbValue, std::string ubValue);
04428 
04429     bool setInitObjValues(int numberOfObj, int* idx, double* value, std::string* name);
04430     bool setInitObjValuesSparse(int numberOfObj, InitObjValue** obj);
04431     bool setInitObjValuesDense(int numberOfObj, double *value);
04432     bool setAnotherInitObjValue(int idx, double value);
04433 
04434     bool setInitObjBounds(int numberOfObj, int* idx, double* lbValue, double* ubValue, std::string* name);
04435     bool setInitObjBoundsSparse(int numberOfObj, InitObjBound** obj);
04436     bool setInitObjBoundsDense(int numberOfObj, double *lb, double *ub);
04437     bool setAnotherInitObjBound(int idx, double lbValue, double ubValue);
04438 
04439     bool setNumberOfOtherObjectiveOptions(int numberOfOther);
04440     bool setOtherObjectiveOptions(int numberOfObj, OtherObjectiveOption** obj);
04441     bool setAnOtherObjectiveOption(OtherObjectiveOption* objOption);
04442 
04456     bool setOtherObjectiveOptionAttributes(int iOther, int numberOfObj,
04457                                            int numberOfEnumerations, std::string name,
04458                                            std::string value, std::string solver,
04459                                            std::string category, std::string type,
04460                                            std::string description);
04461 
04462 
04474     bool setOtherObjectiveOptionObj(int otherOptionNumber, int objNumber,
04475                                     int idx, std::string name, std::string value, std::string lbValue, std::string ubValue);
04476 
04477     bool setInitConValues(int numberOfCon, int* idx, double* value, std::string* name);
04478     bool setInitConValuesSparse(int numberOfCon, InitConValue** con);
04479     bool setInitConValuesDense(int numberOfCon, double *value);
04480     bool setAnotherInitConValue(int idx, double value);
04481 
04482     bool setInitDualValues(int numberOfCon, int* idx, double* lbValue, double* ubValue, std::string* name);
04483     bool setInitDualVarValuesSparse(int numberOfCon, InitDualVarValue** con);
04484     bool setInitDualVarValuesDense(int numberOfCon, double *lb, double *ub);
04485     bool setAnotherInitDualVarValue(int idx, double lbValue, double ubValue);
04486 
04487     bool setNumberOfOtherConstraintOptions(int numberOfOther);
04488     bool setOtherConstraintOptions(int numberOfOptions, OtherConstraintOption** other);
04489     bool setAnOtherConstraintOption(OtherConstraintOption* optionValue);
04490 
04504     bool setOtherConstraintOptionAttributes(int iOther, int numberOfCon,
04505                                             int numberOfEnumerations, std::string name,
04506                                             std::string value, std::string solver,
04507                                             std::string category, std::string type,
04508                                             std::string description);
04509 
04510 
04522     bool setOtherConstraintOptionCon(int otherOptionNumber, int conNumber,
04523                                      int idx, std::string name, std::string value, std::string lbValue, std::string ubValue);
04524 
04525     bool setNumberOfSolverOptions(int numberOfOptions);
04526 
04540     bool setSolverOptionContent(int iOption, int numberOfItems,
04541                                 std::string name,
04542                                 std::string value, std::string solver,
04543                                 std::string category, std::string type,
04544                                 std::string description, std::string *itemList);
04545 
04546     bool setSolverOptions(int numberOfSolverOptions, SolverOption** solverOption);
04547     bool setAnotherSolverOption(std::string name, std::string value, std::string solver,
04548                                 std::string category, std::string type, std::string description);
04549 
04550 
04551     bool setOptionInt(std::string optionName, int optionValue);
04552 
04553     bool setOptionStr(std::string optionName, std::string optionValue);
04554 
04555     bool setOptionDbl(std::string optionName, double value);
04556 
04557 };//OSOption
04558 
04559 #endif

Generated on Thu Sep 22 03:06:02 2011 by  doxygen 1.4.7