OSOption.h

Go to the documentation of this file.

/* $Id: OSOption.h 5284 2017-12-08 13:52:50Z stefan $ */
#ifndef OSOPTION_H
#define OSOPTION_H

#include <string>
#include <vector>
#include "OSGeneral.h"
#include "OSMathUtil.h"



//#define DEBUG


class InstanceLocationOption
{

public:
    std::string locationType;

    std::string value;

    InstanceLocationOption();

    ~InstanceLocationOption();

    bool IsEqual(InstanceLocationOption *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(InstanceLocationOption *that);
}; //InstanceLocationOption


class ContactOption
{

public:
    std::string transportType;

    std::string value;

    ContactOption();
    ~ContactOption();

    bool IsEqual(ContactOption *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(ContactOption *that);
}; //ContactOption


class OtherOption
{

public:
    std::string name;

    std::string value;

    std::string description;

    OtherOption();
    ~OtherOption();

    bool IsEqual(OtherOption *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(OtherOption *that);
}; //OtherOption


class OtherOptions
{

public:
    int numberOfOtherOptions;

    OtherOption **other;

    OtherOptions();
    ~OtherOptions();

    bool IsEqual(OtherOptions *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(OtherOptions *that);

    bool setOther(int numberOfOptions, OtherOption** other);

    bool addOther(std::string name, std::string value, std::string description);
}; //OtherOptions


class GeneralOption
{

public:

    std::string serviceURI;

    std::string serviceName;

    std::string instanceName;

    InstanceLocationOption *instanceLocation;

    std::string jobID;

    std::string solverToInvoke;

    std::string license;

    std::string userName;

    std::string password;

    ContactOption *contact;

    OtherOptions *otherOptions;

    GeneralOption();
    ~GeneralOption();

    bool IsEqual(GeneralOption *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(GeneralOption *that);
};//GeneralOption

class MinDiskSpace
{

public:
    std::string unit;

    std::string description;

    double value;


    MinDiskSpace();
    ~MinDiskSpace();

    bool IsEqual(MinDiskSpace *that);
}; //MinDiskSpace

class MinMemorySize
{

public:
    std::string unit;

    std::string description;

    double value;


    MinMemorySize();
    ~MinMemorySize();

    bool IsEqual(MinMemorySize *that);
}; //MinMemorySize

class MinCPUSpeed
{

public:
    std::string unit;

    std::string description;

    double value;


    MinCPUSpeed();
    ~MinCPUSpeed();

    bool IsEqual(MinCPUSpeed *that);
}; //MinCPUSpeed

class MinCPUNumber
{

public:
    std::string description;

    int value;


    MinCPUNumber();
    ~MinCPUNumber();

    bool IsEqual(MinCPUNumber *that);
}; //MinCPUNumber


class SystemOption
{

public:
    StorageCapacity *minDiskSpace;

    StorageCapacity *minMemorySize;

    CPUSpeed *minCPUSpeed;

    CPUNumber *minCPUNumber;

    OtherOptions *otherOptions;

    SystemOption();
    ~SystemOption();

    bool IsEqual(SystemOption *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(SystemOption *that);
}; //SystemOption


class ServiceOption
{

public:
    std::string type;

    OtherOptions *otherOptions;

    ServiceOption();
    ~ServiceOption();

    bool IsEqual(ServiceOption *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(ServiceOption *that);
}; //ServiceOption


class MaxTime
{

public:
    std::string unit;

    double value;


    MaxTime();
    ~MaxTime();

    bool IsEqual(MaxTime *that);
}; //MaxTime


class JobDependencies
{

public:
    int numberOfJobIDs;

    std::string *jobID;

    JobDependencies();
    ~JobDependencies();

    bool IsEqual(JobDependencies *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(JobDependencies *that);

    bool setJobID(int numberOfJobIDs, std::string *jobID);

    bool addJobID(std::string jobID);
}; //JobDependencies


class DirectoriesAndFiles
{

public:
    int numberOfPaths;

    std::string *path;

    DirectoriesAndFiles();
    ~DirectoriesAndFiles();

    bool IsEqual(DirectoriesAndFiles *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(DirectoriesAndFiles *that);

    bool setPath(int numberOfPaths, std::string *path);
    bool addPath(std::string path);
}; //DirectoriesAndFiles



class PathPair
{

public:
    std::string from;

    std::string to;

    bool makeCopy;

    PathPair();
    ~PathPair();

    bool IsEqual(PathPair *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(PathPair *that);
}; //PathPair


class PathPairs
{

public:
    int numberOfPathPairs;

    PathPair **pathPair;

    PathPairs();
    ~PathPairs();

    bool IsEqual(PathPairs *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(PathPairs *that);

    bool setPathPair(int numberOfPathPairs, PathPair **pathPair);

    bool setPathPair(std::string *from, std::string *to, bool *makeCopy, int numberOfPathPairs);

    bool addPathPair(std::string fromPath, std::string toPath, bool makeCopy);
}; //PathPairs


class Processes
{

public:
    int numberOfProcesses;

    std::string *process;

    Processes();
    ~Processes();

    bool IsEqual(Processes *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(Processes *that);

    bool setProcess(int numberOfProcesses, std::string *process);

    bool addProcess(std::string process);
}; //Processes


class JobOption
{

public:
    TimeSpan *maxTime;

    std::string requestedStartTime;

    JobDependencies *dependencies;

    DirectoriesAndFiles *requiredDirectories;

    DirectoriesAndFiles *requiredFiles;

    DirectoriesAndFiles *directoriesToMake;

    DirectoriesAndFiles *filesToMake;

    PathPairs *inputDirectoriesToMove;

    PathPairs *inputFilesToMove;

    PathPairs *outputFilesToMove;

    PathPairs *outputDirectoriesToMove;

    DirectoriesAndFiles *filesToDelete;

    DirectoriesAndFiles *directoriesToDelete;

    Processes *processesToKill;

    OtherOptions *otherOptions;

    JobOption();
    ~JobOption();

    bool IsEqual(JobOption *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(JobOption *that);
}; //JobOption


class InitVarValue
{

public:
    int idx;

    std::string name;

    double value;

    InitVarValue();
    ~InitVarValue();

    bool IsEqual(InitVarValue *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(InitVarValue *that);
}; //InitVarValue


class InitVariableValues
{

public:
    int numberOfVar;

    InitVarValue **var;

    InitVariableValues();
    ~InitVariableValues();

    bool IsEqual(InitVariableValues *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(InitVariableValues *that);

    bool setVar(int numberOfVar, InitVarValue **var);

    bool setVar(int numberOfVar, InitVarValue **var, ENUM_COMBINE_ARRAYS disp);


    bool setVar(int numberOfVar, int *idx, double *value, std::string *name);

    bool addVar(int idx, double value);

    bool addVar(int numberOfVar, InitVarValue **var);
}; //InitVariableValues


class InitVarValueString
{

public:
    int idx;

    std::string name;

    std::string value;

    InitVarValueString();
    ~InitVarValueString();

    bool IsEqual(InitVarValueString *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(InitVarValueString *that);
}; //InitVarValueString


class InitVariableValuesString
{

public:
    int numberOfVar;

    InitVarValueString **var;

    InitVariableValuesString();
    ~InitVariableValuesString();

    bool IsEqual(InitVariableValuesString *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(InitVariableValuesString *that);

    bool setVar(int numberOfVar, InitVarValueString **var);

    bool setVar(int numberOfVar, InitVarValueString **var, ENUM_COMBINE_ARRAYS disp);


    bool setVar(int numberOfVar, int *idx, std::string *value, std::string* name);

    bool addVar(int idx, std::string value);

    bool addVar(int numberOfVar, InitVarValueString **var);
}; //InitVariableValuesString

class InitBasStatus
{

public:
    int idx;

    std::string value;

    InitBasStatus();
    ~InitBasStatus();

    bool IsEqual(InitBasStatus *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(InitBasStatus *that);
}; //InitBasStatus


class InitialBasisStatus
{

public:
    int numberOfVar;

    InitBasStatus **var;

    InitialBasisStatus();
    ~InitialBasisStatus();

    bool IsEqual(InitialBasisStatus *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(InitialBasisStatus *that);

    bool setVar(int numberOfVar, InitBasStatus **var);

    bool addVar(int idx, std::string value);
}; //InitialBasisStatus

class BranchingWeight
{

public:
    int idx;

    std::string name;

    double value;

    BranchingWeight();
    ~BranchingWeight();

    bool IsEqual(BranchingWeight *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(BranchingWeight *that);
}; //BranchingWeight



class IntegerVariableBranchingWeights
{

public:
    int numberOfVar;

    BranchingWeight **var;

    IntegerVariableBranchingWeights();
    ~IntegerVariableBranchingWeights();

    bool IsEqual(IntegerVariableBranchingWeights *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(IntegerVariableBranchingWeights *that);

    bool setVar(int numberOfVar, BranchingWeight **var);

    bool setVar(int numberOfVar, BranchingWeight **var, ENUM_COMBINE_ARRAYS disp);

    bool setVar(int numberOfVar, int *idx, double *value, std::string* name);

    bool addVar(int idx, double value);

    bool addVar(int numberOfVar, BranchingWeight **var);
}; //IntegerVariableBranchingWeights

class SOSWeights
{

public:
    int sosIdx;

    double groupWeight;

    int numberOfVar;

    BranchingWeight **var;

    SOSWeights();
    ~SOSWeights();

    bool IsEqual(SOSWeights *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(SOSWeights *that);

    bool setVar(int numberOfVar, BranchingWeight **var);

    bool addVar(int idx, double value);
}; //SOSWeights


class SOSVariableBranchingWeights
{

public:
    int numberOfSOS;

    SOSWeights **sos;

    SOSVariableBranchingWeights();
    ~SOSVariableBranchingWeights();

    bool IsEqual(SOSVariableBranchingWeights *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(SOSVariableBranchingWeights *that);

    bool setSOS(int numberOfSOS, SOSWeights **sos);
    bool addSOS(int sosIdx, int nvar, double weight, int* idx, double* value, std::string* name);
}; //SOSVariableBranchingWeights

class OtherVarOption
{

public:
    int idx;

    std::string name;

    std::string value;

    std::string lbValue;

    std::string ubValue;

    OtherVarOption();
    ~OtherVarOption();

    bool IsEqual(OtherVarOption *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(OtherVarOption *that);
}; //OtherVarOption


class OtherVariableOption
{

public:
    int numberOfVar;

    int numberOfEnumerations;

    std::string name;

    std::string value;

    std::string solver;

    std::string category;

    std::string type;

    std::string description;

    OtherVarOption **var;

    std::string varType;

    /* a pointer to OtherOptionOrResultEnumeration objects that will
     * give for each distinct value the set of indices for
     * this user defined variable result
     */
    OtherOptionOrResultEnumeration** enumeration;

    std::string enumType;

    OtherVariableOption();
    ~OtherVariableOption();

    bool IsEqual(OtherVariableOption *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(OtherVariableOption *that);

    bool setVar(int numberOfVar, OtherVarOption **var);

    bool addVar(int idx, std::string value, std::string lbValue, std::string ubValue);
}; //OtherVariableOption


class VariableOption
{

public:
    int numberOfOtherVariableOptions;

    InitVariableValues *initialVariableValues;

    InitVariableValuesString *initialVariableValuesString;

    BasisStatus *initialBasisStatus;

    IntegerVariableBranchingWeights *integerVariableBranchingWeights;

    SOSVariableBranchingWeights *sosVariableBranchingWeights;

    OtherVariableOption **other;

    VariableOption();
    ~VariableOption();

    bool IsEqual(VariableOption *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(VariableOption *that);

    bool setOther(int numberOfOptions, OtherVariableOption  **other);

    bool addOther(OtherVariableOption *other);
}; //VariableOption


class InitObjValue
{

public:
    int idx;

    std::string name;

    double value;

    InitObjValue();
    ~InitObjValue();

    bool IsEqual(InitObjValue *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(InitObjValue *that);
}; //InitObjValue


class InitObjectiveValues
{

public:
    int numberOfObj;

    InitObjValue **obj;

    InitObjectiveValues();
    ~InitObjectiveValues();

    bool IsEqual(InitObjectiveValues *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(InitObjectiveValues *that);

    bool setObj(int numberOfObj, InitObjValue **obj);

    bool setObj(int numberOfObj, InitObjValue **obj, ENUM_COMBINE_ARRAYS disp);


    bool setObj(int numberOfObj, int *idx, double *value, std::string *name);

    bool addObj(int idx, double value);

    bool addObj(int numberOfObj, InitObjValue **obj);
}; //InitObjectiveValues


class InitObjBound
{

public:
    int idx;

    std::string name;

    double lbValue;

    double ubValue;

    InitObjBound();
    ~InitObjBound();

    bool IsEqual(InitObjBound *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(InitObjBound *that);
}; //InitObjBound


class InitObjectiveBounds
{

public:
    int numberOfObj;

    InitObjBound **obj;

    InitObjectiveBounds();
    ~InitObjectiveBounds();

    bool IsEqual(InitObjectiveBounds *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(InitObjectiveBounds *that);

    bool setObj(int numberOfObj, InitObjBound **obj);

    bool setObj(int numberOfObj, InitObjBound **obj, ENUM_COMBINE_ARRAYS disp);


    bool setObj(int numberOfObj, int *idx, double *lbValue, double *ubValue, std::string *name);

    bool addObj(int idx, double lbValue, double ubValue);

    bool addObj(int numberOfObj, InitObjBound **obj);
}; //InitObjectiveBounds


class OtherObjOption
{

public:
    int idx;

    std::string name;

    std::string value;


    std::string lbValue;

    std::string ubValue;
    OtherObjOption();
    ~OtherObjOption();

    bool IsEqual(OtherObjOption *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(OtherObjOption *that);
}; //OtherObjOption


class OtherObjectiveOption
{

public:
    int numberOfObj;

    int numberOfEnumerations;

    std::string name;

    std::string value;

    std::string solver;

    std::string category;

    std::string type;

    std::string description;

    OtherObjOption **obj;

    std::string objType;

    /* a pointer to OtherOptionOrResultEnumeration objects that will
     * give for each distinct value the set of indices for
     * this user defined variable result
     */
    OtherOptionOrResultEnumeration** enumeration;

    std::string enumType;

    OtherObjectiveOption();
    ~OtherObjectiveOption();

    bool IsEqual(OtherObjectiveOption *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(OtherObjectiveOption *that);

    bool setObj(int numberOfObj, OtherObjOption **obj);

    bool addObj(int idx, std::string value, std::string lbValue, std::string ubValue);
}; //OtherObjectiveOption


class ObjectiveOption
{

public:
    int numberOfOtherObjectiveOptions;

    InitObjectiveValues *initialObjectiveValues;

    InitObjectiveBounds *initialObjectiveBounds;

    BasisStatus *initialBasisStatus;

    OtherObjectiveOption **other;

    ObjectiveOption();
    ~ObjectiveOption();

    bool IsEqual(ObjectiveOption *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(ObjectiveOption *that);

    bool setOther(int numberOfOptions, OtherObjectiveOption  **other);



    bool addOther(OtherObjectiveOption *other);
}; //ObjectiveOption


class InitConValue
{

public:
    int idx;

    std::string name;

    double value;

    InitConValue();
    ~InitConValue();

    bool IsEqual(InitConValue *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(InitConValue *that);
}; //InitConValue


class InitConstraintValues
{

public:
    int numberOfCon;

    InitConValue **con;

    InitConstraintValues();
    ~InitConstraintValues();

    bool IsEqual(InitConstraintValues *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(InitConstraintValues *that);

    bool setCon(int numberOfCon, InitConValue **con);

    bool setCon(int numberOfCon, InitConValue **con, ENUM_COMBINE_ARRAYS disp);


    bool setCon(int numberOfCon, int *idx, double *value, std::string *name);

    bool addCon(int idx, double value);

    bool addCon(int numberOfCon, InitConValue **con);
}; //InitConstraintValues


class InitDualVarValue
{

public:
    int idx;

    std::string name;

    double lbDualValue;

    double ubDualValue;

    InitDualVarValue();

    ~InitDualVarValue();

    bool IsEqual(InitDualVarValue *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(InitDualVarValue *that);
}; //InitDualVarValue


class InitDualVariableValues
{

public:
    int numberOfCon;

    InitDualVarValue **con;

    InitDualVariableValues();
    ~InitDualVariableValues();

    bool IsEqual(InitDualVariableValues *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(InitDualVariableValues *that);

    bool setCon(int numberOfCon, InitDualVarValue **con);

    bool setCon(int numberOfCon, InitDualVarValue **con, ENUM_COMBINE_ARRAYS disp);


    bool setCon(int numberOfCon, int *idx, double *lbValue, double *ubValue, std::string *name);

    bool addCon(int idx, double lbDualValue, double ubDualValue);

    bool addCon(int numberOfCon, InitDualVarValue **con);
}; //InitDualVariableValues


class OtherConOption
{

public:
    int idx;

    std::string name;

    std::string value;

    std::string lbValue;

    std::string ubValue;

    OtherConOption();
    ~OtherConOption();

    bool IsEqual(OtherConOption *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(OtherConOption *that);
}; //OtherConOption


class OtherConstraintOption
{

public:
    int numberOfCon;

    int numberOfEnumerations;

    std::string name;

    std::string value;

    std::string solver;

    std::string category;

    std::string type;

    std::string description;

    OtherConOption **con;

    std::string conType;

    /* a pointer to OtherOptionOrResultEnumeration objects that will
     * give for each distinct value the set of indices for
     * this user defined variable result
     */
    OtherOptionOrResultEnumeration** enumeration;

    std::string enumType;

    OtherConstraintOption();
    ~OtherConstraintOption();

    bool IsEqual(OtherConstraintOption *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(OtherConstraintOption *that);

    bool setCon(int numberOfCon, OtherConOption **con);

    bool addCon(int idx, std::string value, std::string lbValue, std::string ubValue);
}; //OtherConstraintOption


class ConstraintOption
{

public:
    int numberOfOtherConstraintOptions;

    InitConstraintValues *initialConstraintValues;

    InitDualVariableValues *initialDualValues;

    BasisStatus *initialBasisStatus;

    OtherConstraintOption **other;

    ConstraintOption();
    ~ConstraintOption();

    bool IsEqual(ConstraintOption *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(ConstraintOption *that);

    bool setOther(int numberOfOptions, OtherConstraintOption  **other);


    bool addOther(OtherConstraintOption *other);
}; //ConstraintOption


class SolverOption
{

public:
    std::string name;

    std::string value;

    std::string solver;

    std::string category;

    std::string type;

    std::string description;

    int numberOfItems;

    std::string* item;

    SolverOption();
    ~SolverOption();

    bool IsEqual(SolverOption *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(SolverOption *that);
}; //SolverOption


class SolverOptions
{

public:
    int numberOfSolverOptions;

    SolverOption **solverOption;

    SolverOptions();
    ~SolverOptions();

    bool IsEqual(SolverOptions *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(SolverOptions *that);

    bool setSolverOptions(int numberOfOptions, SolverOption **solverOption);

    bool addSolverOption(std::string name, std::string value, std::string solver,
                         std::string category, std::string type, std::string description);
}; //SolverOptions


class OptimizationOption
{

public:
    int numberOfVariables;

    int numberOfObjectives;

    int numberOfConstraints;

    VariableOption *variables;

    ObjectiveOption *objectives;

    ConstraintOption *constraints;

    SolverOptions *solverOptions;
    OptimizationOption();
    ~OptimizationOption();

    bool IsEqual(OptimizationOption *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(OptimizationOption *that);
}; //OptimizationOption


class OSOption
{

public:

    GeneralFileHeader *optionHeader;
    GeneralOption *general;
    SystemOption *system;
    ServiceOption *service;
    JobOption *job;
    OptimizationOption *optimization;

    OSOption();
    ~OSOption();

    bool setHeader(std::string name, std::string source,
                         std::string description, std::string fileCreator, std::string licence);

private:
    double* m_mdInitVarValuesDense;

    std::string* m_mdInitVarValuesStringDense;

    int* m_mdInitBasisStatusDense;

    double* m_mdIntegerVariableBranchingWeightsDense;

    double* m_mdInitObjValuesDense;

    double* m_mdInitObjLowerBoundsDense;

    double* m_mdInitObjUpperBoundsDense;

    double* m_mdInitConValuesDense;

    double* m_mdInitDualVarLowerBoundsDense;

    double* m_mdInitDualVarUpperBoundsDense;

public:
    bool IsEqual(OSOption *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(OSOption *that);

public:

    // get() methods...

    std::string  getFileName();

    std::string  getFileSource();

    std::string  getFileDescription();

    std::string  getFileCreator();

    std::string  getFileLicence();

    std::string  getServiceURI();

    std::string  getServiceName();

    std::string  getInstanceName();

    std::string  getInstanceLocation();

    std::string  getInstanceLocationType();

    std::string  getJobID();

    std::string  getSolverToInvoke();

    std::string  getLicense();

    std::string  getUserName();

    std::string  getPassword();

    std::string  getContact();

    std::string  getContactTransportType();

    std::string  getMinDiskSpaceUnit();

    std::string  getMinDiskSpaceDescription();

    std::string  getMinMemoryUnit();

    std::string  getMinMemoryDescription();

    std::string  getMinCPUSpeedUnit();

    std::string  getMinCPUSpeedDescription();

    std::string  getMinCPUNumberDescription();

    std::string  getServiceType();

    std::string  getMaxTimeUnit();

    std::string  getRequestedStartTime();

    std::string  getOptionStr(std::string optionName);

    double  getMinDiskSpace();

    double  getMinMemorySize();

    double  getMinCPUSpeed();

    double  getMaxTime();

    double  getOptionDbl(std::string optionName);

    int  getMinCPUNumber();

    int  getNumberOfOtherGeneralOptions();

    int  getNumberOfOtherSystemOptions();

    int  getNumberOfOtherServiceOptions();

    int  getNumberOfOtherJobOptions();

    int  getNumberOfJobDependencies();

    int  getNumberOfRequiredDirectories();

    int  getNumberOfRequiredFiles();

    int  getNumberOfDirectoriesToMake();

    int  getNumberOfFilesToMake();

    int  getNumberOfInputDirectoriesToMove();

    int  getNumberOfInputFilesToMove();

    int  getNumberOfOutputDirectoriesToMove();

    int  getNumberOfOutputFilesToMove();

    int  getNumberOfFilesToDelete();

    int  getNumberOfDirectoriesToDelete();

    int  getNumberOfProcessesToKill();

    int  getNumberOfVariables();

    int  getNumberOfObjectives();

    int  getNumberOfConstraints();

    int getNumberOfInitVarValues();

    int getNumberOfInitVarValuesString();

    int getNumberOfIntegerVariableBranchingWeights();

    int getNumberOfSOS();

    int getNumberOfSOSVarBranchingWeights(int iSOS);

    int getNumberOfOtherVariableOptions();

    int getNumberOfInitObjValues();

    int getNumberOfInitObjBounds();

    int getNumberOfOtherObjectiveOptions();

    int getNumberOfInitConValues();

    int getNumberOfInitDualVarValues();

    int getNumberOfOtherConstraintOptions();

    int getNumberOfSolverOptions();

    int getOptionInt(std::string optionName);


    OtherOption** getOtherGeneralOptions();

    OtherOption** getOtherSystemOptions();

    OtherOption** getOtherServiceOptions();

    OtherOption** getOtherJobOptions();

    OtherOption** getOtherOptions(std::string elementName);


    OtherOption** getAllOtherOptions();

    std::string* getJobDependencies();

    std::string* getRequiredDirectories();

    std::string* getRequiredFiles();

    std::string* getDirectoriesToMake();

    std::string* getFilesToMake();

    PathPair** getInputDirectoriesToMove();

    PathPair** getInputFilesToMove();

    PathPair** getOutputDirectoriesToMove();

    PathPair** getOutputFilesToMove();

    std::string* getDirectoriesToDelete();

    std::string* getFilesToDelete();

    std::string* getProcessesToKill();

    InitVarValue** getInitVarValuesSparse();

    double* getInitVarValuesDense();

    double* getInitVarValuesDense(int numberOfVariables);

    InitVarValueString** getInitVarValuesStringSparse();

    std::string *getInitVarValuesStringDense();

    std::string *getInitVarValuesStringDense(int numberOfVariables);

    InitBasStatus** getInitBasisStatusSparse();

    std::string *getInitBasisStatusDense();

    int* getVariableInitialBasisStatusDense(int numberOfVariables);

    int getNumberOfInitialBasisElements(int type, int status);

    bool getInitialBasisElements(int type, int status, int* elem);

    BranchingWeight**  getIntegerVariableBranchingWeightsSparse();

    double* getIntegerVariableBranchingWeightsDense();

    double* getIntegerVariableBranchingWeightsDense(int numberOfVariables);

    SOSWeights** getSOSVariableBranchingWeightsSparse();

    std::vector<OtherVariableOption*> getOtherVariableOptions(std::string solver_name);

    OtherVariableOption* getOtherVariableOption(int optionNumber);

    OtherVariableOption** getAllOtherVariableOptions();

    InitObjValue** getInitObjValuesSparse();

    double *getInitObjValuesDense();

    double *getInitObjValuesDense(int numberOfObjectives);

    InitObjBound** getInitObjBoundsSparse();

    double *getInitObjLowerBoundsDense();

    double *getInitObjLowerBoundsDense(int numberOfObjectives);

    double *getInitObjUpperBoundsDense();

    double *getInitObjUpperBoundsDense(int numberOfObjectives);

    int* getObjectiveInitialBasisStatusDense(int numberOfObjectives);

    std::vector<OtherObjectiveOption*> getOtherObjectiveOptions(std::string solver_name);

    OtherObjectiveOption* getOtherObjectiveOption(int optionNumber);

    OtherObjectiveOption** getAllOtherObjectiveOptions();

    InitConValue** getInitConValuesSparse();

    double *getInitConValuesDense();

    double *getInitConValuesDense(int numberOfConstraints);

    InitDualVarValue** getInitDualVarValuesSparse();

    double *getInitDualVarLowerBoundsDense();

    double *getInitDualVarLowerBoundsDense(int numberOfConstraints);


    double *getInitDualVarUpperBoundsDense();

    double *getInitDualVarUpperBoundsDense(int numberOfConstraints);

    int* getSlackVariableInitialBasisStatusDense(int numberOfConstraints);

    std::vector<OtherConstraintOption*> getOtherConstraintOptions(std::string solver_name);

    OtherConstraintOption* getOtherConstraintOption(int optionNumber);

    OtherConstraintOption** getAllOtherConstraintOptions();

    std::vector<SolverOption*> getSolverOptions( std::string solver_name);


    std::vector<SolverOption*> getSolverOptions( std::string solver_name, bool getFreeOptions);

    SolverOption** getAllSolverOptions();

    /* --------------------------------------------------
    *  set() methods
    * -------------------------------------------------- */

    bool setServiceURI( std::string serviceURI);

    bool setServiceName( std::string serviceName);

    bool setInstanceName( std::string instanceName);

    bool setInstanceLocation( std::string instanceLocation);

    bool setInstanceLocation( std::string instanceLocation, std::string locationType);

    bool setInstanceLocationType( std::string locationType);

    bool setJobID( std::string jobID);

    bool setSolverToInvoke( std::string solverToInvoke);

    bool setLicense( std::string license);

    bool setUserName( std::string userName);

    bool setPassword( std::string password);

    bool setContact( std::string contact);

    bool setContact( std::string contact, std::string transportType);

    bool setContactTransportType( std::string transportType);

    bool setOtherGeneralOptions(int numberOfOptions, OtherOption** other);

    bool setAnOtherGeneralOption(std::string name, std::string value, std::string description);

    bool setMinDiskSpace(std::string unit, std::string description, double value);

    bool setMinDiskSpace(double value);

    bool setMinDiskSpaceUnit(std::string unit);

    bool setMinMemorySize(std::string unit, std::string description, double value);

    bool setMinMemorySize(double value);

    bool setMinMemoryUnit(std::string unit);

    bool setMinCPUSpeed(std::string unit, std::string description, double value);

    bool setMinCPUSpeed(double value);

    bool setMinCPUSpeedUnit(std::string unit);

    bool setMinCPUNumber( int number, std::string description);

    bool setMinCPUNumber( int number);

    bool setOtherSystemOptions(int numberOfOptions, OtherOption** other);

    bool setAnOtherSystemOption(std::string name, std::string value, std::string description);


    bool setServiceType( std::string serviceType);

    bool setOtherServiceOptions(int numberOfOptions, OtherOption** other);

    bool setAnOtherServiceOption(std::string name, std::string value, std::string description);


    bool setMaxTime(double value, std::string unit);

    bool setMaxTime(double value);

    bool setMaxTimeUnit(std::string unit);

    bool setRequestedStartTime(std::string time);

    bool setJobDependencies(int numberOfDependencies, std::string* jobDependencies);
    bool setAnotherJobDependency(std::string jobID);

    bool setRequiredDirectories(int numberOfPaths, std::string* paths);
    bool setAnotherRequiredDirectory(std::string path);

    bool setRequiredFiles(int numberOfPaths, std::string* paths);
    bool setAnotherRequiredFile(std::string path);

    bool setDirectoriesToMake(int numberOfPaths, std::string* paths);
    bool setAnotherDirectoryToMake(std::string path);

    bool setFilesToMake(int numberOfPaths, std::string* paths);
    bool setAnotherFileToMake(std::string path);

    bool setPathPairs(int object, std::string *from, std::string *to, bool *makeCopy, int numberOfPathPairs);

    bool setInputDirectoriesToMove(int numberOfPathPairs, PathPair** pathPair);
    bool setAnotherInputDirectoryToMove(std::string fromPath, std::string toPath, bool makeCopy);

    bool setInputFilesToMove(int numberOfPathPairs, PathPair** pathPair);
    bool setAnotherInputFileToMove(std::string fromPath, std::string toPath, bool makeCopy);

    bool setOutputFilesToMove(int numberOfPathPairs, PathPair** pathPair);
    bool setAnotherOutputFileToMove(std::string fromPath, std::string toPath, bool makeCopy);

    bool setOutputDirectoriesToMove(int numberOfPathPairs, PathPair** pathPair);
    bool setAnotherOutputDirectoryToMove(std::string fromPath, std::string toPath, bool makeCopy);

    bool setFilesToDelete(int numberOfPaths, std::string* paths);
    bool setAnotherFileToDelete(std::string path);

    bool setDirectoriesToDelete(int numberOfPaths, std::string* paths);
    bool setAnotherDirectoryToDelete(std::string path);

    bool setProcessesToKill(int numberOfProcesses, std::string* processes);
    bool setAnotherProcessToKill(std::string process);

    bool setOtherJobOptions(int numberOfOptions, OtherOption** other);
    bool setAnOtherJobOption(std::string name, std::string value, std::string description);


    bool setNumberOfVariables(int numberOfVariables);

    bool setNumberOfObjectives(int numberOfObjectives);

    bool setNumberOfConstraints(int numberOfConstraints);

    bool setInitVarValues(int numberOfVar, int* idx, double* value, std::string* name);
    bool setInitVarValuesSparse(int numberOfVar, InitVarValue** var);
    bool setInitVarValuesSparse(int numberOfVar, InitVarValue** var, ENUM_COMBINE_ARRAYS disp);
    bool setInitVarValuesDense(int numberOfVar, double *value);
    bool setAnotherInitVarValue(int idx, double value);

    bool setInitVarValuesString(int numberOfVar, int* idx, std::string* value, std::string* name);
    bool setInitVarValuesStringSparse(int numberOfVar, InitVarValueString** var);
    bool setInitVarValuesStringSparse(int numberOfVar, InitVarValueString** var, ENUM_COMBINE_ARRAYS disp);
    bool setInitVarValuesStringDense(int numberOfVar, std::string *value);
    bool setAnotherInitVarValueString(int idx, std::string value);

    bool setInitBasisStatus(int object, int status, int *i, int ni);
    bool setInitBasisStatusSparse(int numberOfVar, InitBasStatus** var);
    bool setInitBasisStatusSparse(int numberOfVar, InitBasStatus** var, ENUM_COMBINE_ARRAYS disp);
    bool setInitBasisStatusDense(int numberOfVar, std::string *var);

    bool setAnotherInitBasisStatus(int type, int idx, int status);

    bool setIntegerVariableBranchingWeights(int numberOfVar, int* idx, double* value, std::string* name);
    bool setIntegerVariableBranchingWeightsSparse(int numberOfVar, BranchingWeight** var);
    bool setIntegerVariableBranchingWeightsSparse(int numberOfVar, BranchingWeight** var, ENUM_COMBINE_ARRAYS disp);
    bool setIntegerVariableBranchingWeightsDense(int numberOfVar, double *value);
    bool setAnotherIntegerVariableBranchingWeight(int idx, double value);

    bool setSOSVariableBranchingWeights(int numberOfSOS, SOSWeights** sos);
    bool setAnotherSOSVariableBranchingWeight(int sosIdx, int nvar, double weight, int* idx, double* value, std::string* name);

    bool setNumberOfOtherVariableOptions(int numberOfOther);
    bool setOtherVariableOptions(int numberOfVar, OtherVariableOption** var);
    bool setAnOtherVariableOption(OtherVariableOption* varOption);

    bool setOtherVariableOptionAttributes(int iOther, int numberOfVar,
                                          int numberOfEnumerations, std::string name,
                                          std::string value, std::string solver,
                                          std::string category, std::string type,
                                          std::string varType, std::string enumType,
                                          std::string description);


    bool setOtherOptionOrResultEnumeration(int object, int otherOptionNumber, int enumerationNumber,
                                   int numberOfEl, std::string value, std::string description, int* idxArray);

    bool setOtherVariableOptionVar(int otherOptionNumber, int varNumber,
                                   int idx, std::string name, std::string value, std::string lbValue, std::string ubValue);

    bool setInitObjValues(int numberOfObj, int* idx, double* value, std::string* name);
    bool setInitObjValuesSparse(int numberOfObj, InitObjValue** obj);
    bool setInitObjValuesSparse(int numberOfObj, InitObjValue** obj, ENUM_COMBINE_ARRAYS disp);
    bool setInitObjValuesDense(int numberOfObj, double *value);
    bool setAnotherInitObjValue(int idx, double value);

    bool setInitObjBounds(int numberOfObj, int* idx, double* lbValue, double* ubValue, std::string* name);
    bool setInitObjBoundsSparse(int numberOfObj, InitObjBound** obj);
    bool setInitObjBoundsSparse(int numberOfObj, InitObjBound** obj, ENUM_COMBINE_ARRAYS disp);
    bool setInitObjBoundsDense(int numberOfObj, double *lb, double *ub);
    bool setAnotherInitObjBound(int idx, double lbValue, double ubValue);

    bool setNumberOfOtherObjectiveOptions(int numberOfOther);
    bool setOtherObjectiveOptions(int numberOfObj, OtherObjectiveOption** obj);
    //bool setOtherObjectiveOptions(int numberOfObj, OtherObjectiveOption** obj, ENUM_COMBINE_ARRAYS disp);
    bool setAnOtherObjectiveOption(OtherObjectiveOption* objOption);

    bool setOtherObjectiveOptionAttributes(int iOther, int numberOfObj,
                                           int numberOfEnumerations, std::string name,
                                           std::string value, std::string solver,
                                           std::string category, std::string type,
                                           std::string objType, std::string enumType,
                                           std::string description);


    bool setOtherObjectiveOptionObj(int otherOptionNumber, int objNumber,
                                    int idx, std::string name, std::string value, std::string lbValue, std::string ubValue);

    bool setInitConValues(int numberOfCon, int* idx, double* value, std::string* name);
    bool setInitConValuesSparse(int numberOfCon, InitConValue** con);
    bool setInitConValuesSparse(int numberOfCon, InitConValue** con, ENUM_COMBINE_ARRAYS disp);
    bool setInitConValuesDense(int numberOfCon, double *value);
    bool setAnotherInitConValue(int idx, double value);

    bool setInitDualValues(int numberOfCon, int* idx, double* lbValue, double* ubValue, std::string* name);
    bool setInitDualVarValuesSparse(int numberOfCon, InitDualVarValue** con);
    bool setInitDualVarValuesSparse(int numberOfCon, InitDualVarValue** con, ENUM_COMBINE_ARRAYS disp);
    bool setInitDualVarValuesDense(int numberOfCon, double *lb, double *ub);
    bool setAnotherInitDualVarValue(int idx, double lbValue, double ubValue);

    bool setNumberOfOtherConstraintOptions(int numberOfOther);
    bool setOtherConstraintOptions(int numberOfOptions, OtherConstraintOption** other);
    //bool setOtherConstraintOptions(int numberOfOptions, OtherConstraintOption** other, ENUM_COMBINE_ARRAYS disp);
    bool setAnOtherConstraintOption(OtherConstraintOption* optionValue);

    bool setOtherConstraintOptionAttributes(int iOther, int numberOfCon,
                                            int numberOfEnumerations, std::string name,
                                            std::string value, std::string solver,
                                            std::string category, std::string type,
                                            std::string conType, std::string enumType,
                                            std::string description);


    bool setOtherConstraintOptionCon(int otherOptionNumber, int conNumber,
                                     int idx, std::string name, std::string value, std::string lbValue, std::string ubValue);

    bool setNumberOfSolverOptions(int numberOfOptions);

    bool setSolverOptionContent(int iOption, int numberOfItems,
                                std::string name,
                                std::string value, std::string solver,
                                std::string category, std::string type,
                                std::string description, std::string *itemList);

    bool setSolverOptions(int numberOfSolverOptions, SolverOption** solverOption);
    bool setAnotherSolverOption(std::string name, std::string value, std::string solver,
                                std::string category, std::string type, std::string description);


    bool setOptionInt(std::string optionName, int optionValue);

    bool setOptionStr(std::string optionName, std::string optionValue);

    bool setOptionDbl(std::string optionName, double value);

};//OSOption

#endif