OSResult.h

Go to the documentation of this file.

/* $Id: OSResult.h 5284 2017-12-08 13:52:50Z stefan $ */
#ifndef OSRESULT_H
#define OSRESULT_H
#include <string>
#include <vector>
#include "OSGeneral.h"
#include "OSMatrix.h"

//#define DEBUG


struct IndexStringPair
{
    int idx;

    std::string value;

};


class GeneralSubstatus
{

public:

    std::string name;

    std::string description;

    GeneralSubstatus();
    ~GeneralSubstatus();

    bool IsEqual(GeneralSubstatus *that);

    bool setRandom(double density, bool conformant);

};//GeneralSubstatus


class GeneralStatus
{

public:

    int numberOfSubstatuses;

    std::string type;

    std::string description;

    GeneralSubstatus **substatus;

    GeneralStatus();
    ~GeneralStatus();

    bool IsEqual(GeneralStatus *that);

    bool setRandom(double density, bool conformant);

};//GeneralStatus


class OtherResult
{

public:

    std::string name;

    std::string value;

    std::string description;

    OtherResult();
    ~OtherResult();

    bool IsEqual(OtherResult *that);

    bool setRandom(double density, bool conformant);

};//OtherResult


class OtherResults
{

public:

    int numberOfOtherResults;

    OtherResult** other;

    OtherResults();
    ~OtherResults();

    bool IsEqual(OtherResults *that);

    bool setRandom(double density, bool conformant);

};//OtherResults

class GeneralResult
{
public:

    GeneralStatus *generalStatus;

    std::string message;

    std::string serviceURI;

    std::string serviceName;

    std::string instanceName;

    std::string jobID;

    std::string solverInvoked;

    std::string timeStamp;

    OtherResults *otherResults;


    GeneralResult();
    ~GeneralResult();

    bool IsEqual(GeneralResult *that);

    bool setRandom(double density, bool conformant);
};//class GeneralResult


class SystemResult
{
public:

    std::string systemInformation;

    StorageCapacity *availableDiskSpace;

    StorageCapacity *availableMemory;

    CPUSpeed *availableCPUSpeed;

    CPUNumber *availableCPUNumber;

    OtherResults *otherResults;

    SystemResult();
    ~SystemResult();

    bool IsEqual(SystemResult *that);

    bool setRandom(double density, bool conformant);
};//class SystemResult


class ServiceResult
{
public:

    std::string currentState;

    int currentJobCount;

    int totalJobsSoFar;

    std::string timeServiceStarted;

    double serviceUtilization;

    OtherResults *otherResults;

    ServiceResult();
    ~ServiceResult();

    bool IsEqual(ServiceResult *that);

    bool setRandom(double density, bool conformant);
};//class ServiceResult

#if 0

class Time
{
public:

    std::string type;

    std::string category;

    std::string unit;

    std::string description;

    double value;

    Time();
    ~Time();

    bool IsEqual(Time *that);

    bool setRandom(double density, bool conformant);
};//class Time
#endif

class TimeMeasurement : public TimeSpan
{
public:

    std::string type;

    std::string category;

    std::string description;

    TimeMeasurement();
    ~TimeMeasurement();

    bool IsEqual(TimeMeasurement *that);

    bool setRandom(double density, bool conformant);
};//class TimeMeasurement


class TimingInformation
{
public:

    int numberOfTimes;

    TimeMeasurement** time;

    TimingInformation();
    ~TimingInformation();

    bool IsEqual(TimingInformation *that);

    bool setRandom(double density, bool conformant);
};//class TimingInformation


class JobResult
{
public:

    std::string status;

    std::string submitTime;

    std::string scheduledStartTime;

    std::string actualStartTime;

    std::string endTime;

    TimingInformation* timingInformation;

    StorageCapacity *usedDiskSpace;

    StorageCapacity *usedMemory;

    CPUSpeed *usedCPUSpeed;

    CPUNumber *usedCPUNumber;

    OtherResults *otherResults;

    JobResult();
    ~JobResult();

    bool IsEqual(JobResult *that);

    bool setRandom(double density, bool conformant);
};//class JobResult




class OptimizationSolutionSubstatus
{
public:

    std::string type;

    std::string description;

    OptimizationSolutionSubstatus();
    ~OptimizationSolutionSubstatus();

    bool IsEqual(OptimizationSolutionSubstatus *that);

    bool setRandom(double density, bool conformant);

};//OptimizationSolutionSubstatus


class OptimizationSolutionStatus
{
public:

    int numberOfSubstatuses;

    std::string type;

    std::string description;

    OptimizationSolutionSubstatus** substatus;

    OptimizationSolutionStatus();
    ~OptimizationSolutionStatus();

    bool IsEqual(OptimizationSolutionStatus *that);

    bool setRandom(double density, bool conformant);

};//OptimizationSolutionStatus


class VarValue
{
public:

    int idx;

    std::string name;

    /* value is the value of the variable indexed by idx
     * in the solution
     */
    double value;

    VarValue();
    ~VarValue();

    bool IsEqual(VarValue *that);

    bool setRandom(double density, bool conformant);

};// class VarValue


class VariableValues
{
public:

    int numberOfVar;

    VarValue** var;


    VariableValues();

    ~VariableValues();

    bool IsEqual(VariableValues *that);

    bool setRandom(double density, bool conformant);

};// class VariableValues


class VarValueString
{
public:

    int idx;

    std::string name;

    /* value is the value of the variable indexed by idx
     * in the solution
     */
    std::string value;

    VarValueString();

    ~VarValueString();

    bool IsEqual(VarValueString *that);

    bool setRandom(double density, bool conformant);

};// class VarValueString


class VariableValuesString
{
public:

    int numberOfVar;

    VarValueString** var;


    VariableValuesString();

    ~VariableValuesString();

    bool IsEqual(VariableValuesString *that);

    bool setRandom(double density, bool conformant);

};// class VariableValuesString


class OtherVarResult
{
public:

    int idx;

    std::string name;

    std::string value;

    OtherVarResult();
    ~OtherVarResult();

    bool IsEqual(OtherVarResult *that);

    bool setRandom(double density, bool conformant);

};//OtherVarResult



class OtherVariableResult
{
public:

    int numberOfVar;

    int numberOfEnumerations;

    std::string name;

    std::string value;

    std::string type;

    std::string description;

    std::string solver;

    std::string category;

    /* a pointer to OtherVarResult objects that will
     * give for each variable the index and value for
     * this user defined variable result
     */
    OtherVarResult** 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;

    OtherVariableResult();

    ~OtherVariableResult();

    bool IsEqual(OtherVariableResult *that);

    bool setRandom(double density, bool conformant);

};//OtherVariableResult


class VariableSolution
{
public:

    int numberOfOtherVariableResults;

    VariableValues *values;

    VariableValuesString *valuesString;

    BasisStatus *basisStatus;

    OtherVariableResult** other;

    VariableSolution();

    ~VariableSolution();

    bool IsEqual(VariableSolution *that);

    bool setRandom(double density, bool conformant);

};// class VariableSolution


class ObjValue
{
public:

    int idx;

    std::string name;

    double value;

    ObjValue();

    ~ObjValue();

    bool IsEqual(ObjValue *that);

    bool setRandom(double density, bool conformant);
};//ObjValue

class ObjectiveValues
{
public:

    int numberOfObj;

    ObjValue** obj;

    ObjectiveValues();

    ~ObjectiveValues();

    bool IsEqual(ObjectiveValues *that);

    bool setRandom(double density, bool conformant);

};//ObjectiveValues


class OtherObjResult
{
public:

    int idx;

    std::string name;

    std::string value;

    OtherObjResult();

    ~OtherObjResult();

    bool IsEqual(OtherObjResult *that);

    bool setRandom(double density, bool conformant);

};//OtherObjResult


class OtherObjectiveResult
{
public:

    int numberOfObj;

    int numberOfEnumerations;

    std::string name;

    std::string value;

    std::string type;

    std::string description;

    std::string solver;

    std::string category;

    /* a pointer to OtherObjResult objects that will
     * give for each objective function the index and
     * value for this user defined objective function result
     */
    OtherObjResult** 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;

    OtherObjectiveResult();

    ~OtherObjectiveResult();

    bool IsEqual(OtherObjectiveResult *that);

    bool setRandom(double density, bool conformant);

};//OtherObjectiveResult



class ObjectiveSolution
{
public:

    int numberOfOtherObjectiveResults;

    ObjectiveValues *values;

    BasisStatus *basisStatus;

    OtherObjectiveResult** other;

    ObjectiveSolution();

    ~ObjectiveSolution();

    bool IsEqual(ObjectiveSolution *that);

    bool setRandom(double density, bool conformant);

};//ObjectiveSolution



class DualVarValue
{
public:

    int idx;

    std::string name;

    double value;

    DualVarValue();

    ~DualVarValue();

    bool IsEqual(DualVarValue *that);

    bool setRandom(double density, bool conformant);

};//DualVarValue



class DualVariableValues
{
public:

    int numberOfCon;

    DualVarValue** con;

    DualVariableValues();

    ~DualVariableValues();

    bool IsEqual(DualVariableValues *that);

    bool setRandom(double density, bool conformant);

};//DualVariableValues


class OtherConResult
{
public:

    int idx;

    std::string name;

    std::string value;

    OtherConResult();

    ~OtherConResult();

    bool IsEqual(OtherConResult *that);

    bool setRandom(double density, bool conformant);

};//OtherConResult


class OtherConstraintResult
{
public:

    int numberOfCon;

    int numberOfEnumerations;

    std::string name;

    std::string value;

    std::string type;

    std::string description;

    std::string solver;

    std::string category;

    /* a vector of OtherConResult objects that will
     * give for each constraint the index and
     * value for this user defined objective function result
     */
    OtherConResult** 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;

    OtherConstraintResult();

    ~OtherConstraintResult();

    bool IsEqual(OtherConstraintResult *that);

    bool setRandom(double density, bool conformant);

};//OtherConstraintResult


class ConstraintSolution
{

public:

    int numberOfOtherConstraintResults;

    DualVariableValues *dualValues;

    BasisStatus *basisStatus;

    OtherConstraintResult** other;

    ConstraintSolution();

    ~ConstraintSolution();

    bool IsEqual(ConstraintSolution *that);

    bool setRandom(double density, bool conformant);

};//ConstraintSolution

class MatrixVariableValues
{
public:
    int numberOfMatrixVar;

    OSMatrixWithMatrixVarIdx** matrixVar;

    MatrixVariableValues();

    ~MatrixVariableValues();

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

class OtherMatrixVariableResult
{
public:
    std::string name;

    std::string description;
    std::string value;
    std::string type;
    std::string solver;
    std::string category;

    int numberOfMatrixVar;

    std::string matrixType;
 
    OSMatrixWithMatrixVarIdx** matrixVar;
    
    int numberOfEnumerations;

    std::string enumType;

    OtherOptionOrResultEnumeration** enumeration;

    OtherMatrixVariableResult();

    OtherMatrixVariableResult(std::string name_);

    ~OtherMatrixVariableResult();

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


class MatrixVariableSolution
{
public:
    int numberOfOtherMatrixVariableResults;

    MatrixVariableValues* values;

    OtherMatrixVariableResult** other;

    MatrixVariableSolution();

    ~MatrixVariableSolution();

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


class MatrixObjectiveSolution
{
public:
    int numberOfOtherMatrixObjectiveResults;

    OSMatrixWithMatrixObjIdx** matrixObj;

    MatrixObjectiveSolution();

    ~MatrixObjectiveSolution();

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


class MatrixConstraintSolution
{
public:
    int numberOfOtherMatrixConstraintResults;

    OSMatrixWithMatrixConIdx** matrixCon;

    MatrixConstraintSolution();

    ~MatrixConstraintSolution();

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


class OtherSolutionResult; //forward declaration

class MatrixProgrammingSolution
{
public:
    int numberOfOtherMatrixProgrammingResults;

    OtherSolutionResult** other;

    MatrixVariableSolution* matrixVariables;

    MatrixObjectiveSolution* matrixObjectives;

    MatrixConstraintSolution* matrixConstraints;


    MatrixProgrammingSolution();

    ~MatrixProgrammingSolution();

    bool IsEqual(MatrixProgrammingSolution *that);

    bool setRandom(double density, bool conformant, int iMin, int iMax);

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


class OtherSolutionResult
{
public:

    std::string name;

    std::string value;

    std::string category;

    std::string description;

    int numberOfItems;

    std::string *item;

    OtherSolutionResult();

    ~OtherSolutionResult();

    bool IsEqual(OtherSolutionResult *that);

    bool setRandom(double density, bool conformant);

};//OtherSolutionResult




class OtherSolutionResults
{
public:

    int numberOfOtherSolutionResults;

    OtherSolutionResult **otherSolutionResult;

    OtherSolutionResults();

    ~OtherSolutionResults();

    bool IsEqual(OtherSolutionResults *that);

    bool setRandom(double density, bool conformant);

};//OtherSolutionResults



class OptimizationSolution
{
public:

    int targetObjectiveIdx;

    std::string targetObjectiveName;

    bool weightedObjectives;

    OptimizationSolutionStatus *status;

    std::string message;

    VariableSolution *variables;
    ConstraintSolution *constraints;

    ObjectiveSolution *objectives;

    MatrixProgrammingSolution *matrixProgramming;

    OtherSolutionResults *otherSolutionResults;

    OptimizationSolution();

    ~OptimizationSolution();

    bool IsEqual(OptimizationSolution *that);

    bool setRandom(double density, bool conformant);

};// class OptimizationSolution


class SolverOutput
{
public:

    std::string name;

    std::string category;

    std::string description;

    int numberOfItems;

    std::string *item;

    SolverOutput();

    ~SolverOutput();

    bool IsEqual(SolverOutput *that);

    bool setRandom(double density, bool conformant);

};//SolverOutput



class OtherSolverOutput
{
public:

    int numberOfSolverOutputs;

    SolverOutput **solverOutput;

    OtherSolverOutput();

    ~OtherSolverOutput();

    bool IsEqual(OtherSolverOutput *that);

    bool setRandom(double density, bool conformant);

};//OtherSolverOutput



class OptimizationResult
{
public:

    int numberOfSolutions;

    int numberOfVariables;

    int numberOfObjectives;

    int numberOfConstraints;

    OptimizationSolution **solution;

    OtherSolverOutput *otherSolverOutput;

    OptimizationResult();

    ~OptimizationResult();

    bool IsEqual(OptimizationResult *that);

    bool setRandom(double density, bool conformant);

};// class OptimizationResult



class OSResult
{

public:

    GeneralFileHeader *resultHeader;

    GeneralResult *general;

    SystemResult *system;

    ServiceResult *service;

    JobResult *job;

    OptimizationResult *optimization;

    OSResult();

    ~OSResult();


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

public:

    int m_iVariableNumber;

    int m_iObjectiveNumber;

    int m_iConstraintNumber;

    int m_iNumberOfOtherVariableResults;

    double *m_mdPrimalValues;

    double *m_mdDualValues;


    std::vector<IndexValuePair*>  primalVals;

    std::vector<IndexValuePair*>  dualVals;


public:
    bool IsEqual(OSResult *that);


    bool setRandom(double density, bool conformant);



public:

    GeneralStatus* getGeneralStatus();

    std::string getGeneralStatusType();

    std::string getGeneralStatusDescription();

    int getNumberOfGeneralSubstatuses();

    std::string getGeneralSubstatusName(int i);

    std::string getGeneralSubstatusDescription(int i);

    std::string getGeneralMessage();

    std::string getServiceName();

    std::string getServiceURI();

    std::string getInstanceName();

    std::string getJobID();

    std::string getSolverInvoked();

    std::string getTimeStamp();

    int getNumberOfOtherGeneralResults();

    std::string getOtherGeneralResultName(int idx);

    /* */
    std::string getOtherGeneralResultValue(int idx);
    /* */
    std::string getOtherGeneralResultDescription(int idx);
    /* */
    std::string getSystemInformation();
    /* */
    std::string getAvailableDiskSpaceUnit();
    /* */
    std::string getAvailableDiskSpaceDescription();
    /* */
    double getAvailableDiskSpaceValue();
    /* */
    std::string getAvailableMemoryUnit();
    /* */
    std::string getAvailableMemoryDescription();
    /* */
    double getAvailableMemoryValue();
    /* */
    std::string getAvailableCPUSpeedUnit();
    /* */
    std::string getAvailableCPUSpeedDescription();
    /* */
    double getAvailableCPUSpeedValue();
    /* */
    std::string getAvailableCPUNumberDescription();
    /* */
    int getAvailableCPUNumberValue();
    /* */
    int getNumberOfOtherSystemResults();
    /* */
    std::string getOtherSystemResultName(int idx);
    /* */
    std::string getOtherSystemResultValue(int idx);
    /* */
    std::string getOtherSystemResultDescription(int idx);
    /* */
    std::string getCurrentState();
    /* */
    int getCurrentJobCount();
    /* */
    int getTotalJobsSoFar();
    /* */
    std::string getTimeServiceStarted();
    /* */
    double getServiceUtilization();
    /* */
    int getNumberOfOtherServiceResults();
    /* */
    std::string getOtherServiceResultName(int idx);
    /* */
    std::string getOtherServiceResultValue(int idx);
    /* */
    std::string getOtherServiceResultDescription(int idx);
    /* */
    std::string getJobStatus();
    /* */
    std::string getJobSubmitTime();
    /* */
    std::string getScheduledStartTime();
    /* */
    std::string getActualStartTime();
    /* */
    std::string getJobEndTime();

    int getTimeNumber();

    double getTimeValue();

    /* */
    int getNumberOfTimes();
    /* */
    std::string getTimingInfoUnit(int idx);
    /* */
    std::string getTimingInfoType(int idx);
    /* */
    std::string getTimingInfoCategory(int idx);
    /* */
    std::string getTimingInfoDescription(int idx);
    /* */
    double getTimingInfoValue(int idx);
    /* */
    std::string getUsedDiskSpaceUnit();
    /* */
    std::string getUsedDiskSpaceDescription();
    /* */
    double getUsedDiskSpaceValue();
    /* */
    std::string getUsedMemoryUnit();
    /* */
    std::string getUsedMemoryDescription();
    /* */
    double getUsedMemoryValue();
    /* */
    std::string getUsedCPUSpeedUnit();
    /* */
    std::string getUsedCPUSpeedDescription();
    /* */
    double getUsedCPUSpeedValue();
    /* */
    std::string getUsedCPUNumberDescription();
    /* */
    int getUsedCPUNumberValue();
    /* */
    int getNumberOfOtherJobResults();
    /* */
    std::string getOtherJobResultName(int idx);
    /* */
    std::string getOtherJobResultValue(int idx);
    /* */
    std::string getOtherJobResultDescription(int idx);

    int getVariableNumber();

    int getObjectiveNumber();

    int getConstraintNumber();

    int getSolutionNumber();


    OptimizationSolutionStatus* getSolutionStatus( int solIdx);

    std::string getSolutionStatusType(int solIdx);

    std::string getSolutionStatusDescription(int solIdx);

    /* */
    int getNumberOfSolutionSubstatuses(int solIdx);
    /* */
    std::string getSolutionSubstatusType(int solIdx, int substatusIdx);
    /* */
    std::string getSolutionSubstatusDescription(int solIdx, int substatusIdx);
    /* */
    int getSolutionTargetObjectiveIdx(int solIdx);
    /* */
    std::string getSolutionTargetObjectiveName(int solIdx);

    bool getSolutionWeightedObjectives(int solIdx);

    std::string getSolutionMessage(int solIdx);

    /* */
    int getNumberOfPrimalVariableValues(int solIdx);
    /* */
    int getNumberOfVarValues(int solIdx);
    /* */
    int getVarValueIdx(int solIdx, int varIdx);
    /* */
    std::string getVarValueName(int solIdx, int varIdx);
    /* */
    double getVarValue(int solIdx, int varIdx);

    std::vector<IndexValuePair*> getOptimalPrimalVariableValues(int solIdx);

    /* */
    int getNumberOfVarValuesString(int solIdx);
    /* */
    int getVarValueStringIdx(int solIdx, int varIdx);
    /* */
    std::string getVarValueStringName(int solIdx, int varIdx);
    /* */
    std::string getVarValueString(int solIdx, int varIdx);

    int getBasisStatusNumberOfEl(int solIdx, int object, int status);

    int getBasisStatusEl(int solIdx, int object, int status, int j);


    int getBasisInformationDense(int solIdx, int object, int* resultArray, int dim);

    int getNumberOfOtherVariableResults( int solIdx);

    int getAnOtherVariableResultNumberOfVar(int solIdx, int iOther);

    /* */
    std::string getOtherVariableResultName(int solIdx, int otherIdx);
    /* */
    std::string getOtherVariableResultType(int solIdx, int otherIdx);
    /* */
    std::string getOtherVariableResultValue(int solIdx, int otherIdx);
    /* */
    std::string getOtherVariableResultDescription(int solIdx, int otherIdx);
    /* */
    int getOtherVariableResultNumberOfVar(int solIdx, int otherIdx);
    /* */
    int getOtherVariableResultNumberOfEnumerations(int solIdx, int otherIdx);
    /* */
    int getOtherVariableResultVarIdx(int solIdx, int otherIdx, int varIdx);
    /* */
    std::string getOtherVariableResultVar(int solIdx, int otherIdx, int varIdx);

    std::string getOtherVariableResultArrayType(int solIdx,int otherIdx);

    std::string getOtherVariableResultEnumerationValue(int solIdx,int otherIdx, int enumIdx);

    std::string getOtherVariableResultEnumerationDescription(int solIdx,int otherIdx, int enumIdx);

    int  getOtherVariableResultEnumerationNumberOfEl(int solIdx, int otherIdx, int enumIdx);

    int getOtherVariableResultEnumerationEl(int solIdx,int otherIdx, int enumIdx, int j);

    int getOtherVariableResultArrayDense(int solIdx, int otherIdx, std::string* resultArray, int dim);


    /* */
    int getNumberOfObjValues(int solIdx);
    /* */
    int getObjValueIdx(int solIdx, int objIdx);
    /* */
    std::string getObjValueName(int solIdx, int objIdx);
    /* */
    double getObjValue(int solIdx, int objIdx);

    double getOptimalObjValue(int objIdx, int solIdx);

    /* */
    int getNumberOfOtherObjectiveResults(int solIdx);
    /* */
    std::string getOtherObjectiveResultName(int solIdx, int otherIdx);
    /* */
    std::string getOtherObjectiveResultType(int solIdx, int otherIdx);
    /* */
    std::string getOtherObjectiveResultValue(int solIdx, int otherIdx);
    /* */
    std::string getOtherObjectiveResultDescription(int solIdx, int otherIdx);
    /* */
    int getOtherObjectiveResultNumberOfObj(int solIdx, int otherIdx);
    /* */
    int getOtherObjectiveResultNumberOfEnumerations(int solIdx, int otherIdx);
    /* */
    int getOtherObjectiveResultObjIdx(int solIdx, int otherIdx, int objIdx);
    /* */
    std::string getOtherObjectiveResultObj(int solIdx, int otherIdx, int objIdx);

    std::string getOtherObjectiveResultArrayType(int solIdx,int otherIdx);

    std::string getOtherObjectiveResultEnumerationValue(int solIdx,int otherIdx, int enumIdx);

    std::string getOtherObjectiveResultEnumerationDescription(int solIdx,int otherIdx, int enumIdx);

    int  getOtherObjectiveResultEnumerationNumberOfEl(int solIdx,int otherIdx, int enumIdx);

    int getOtherObjectiveResultEnumerationEl(int solIdx,int otherIdx, int enumIdx, int j);

    int getOtherObjectiveResultArrayDense(int solIdx, int otherIdx, std::string* resultArray, int dim);


    /* */
    int getNumberOfDualValues(int solIdx);
    /* */
    int getDualValueIdx(int solIdx, int conIdx);
    /* */
    std::string getDualValueName(int solIdx, int objIdx);
    /* */
    double getDualValue(int solIdx, int conIdx);

    std::vector<IndexValuePair*> getOptimalDualVariableValues(int solIdx);

    /* */
    int getNumberOfOtherConstraintResults(int solIdx);
    /* */
    std::string getOtherConstraintResultName(int solIdx, int otherIdx);
    /* */
    std::string getOtherConstraintResultType(int solIdx, int otherIdx);
    /* */
    std::string getOtherConstraintResultValue(int solIdx, int otherIdx);
    /* */
    std::string getOtherConstraintResultDescription(int solIdx, int otherIdx);
    /* */
    int getOtherConstraintResultNumberOfCon(int solIdx, int otherIdx);
    /* */
    int getOtherConstraintResultNumberOfEnumerations(int solIdx, int otherIdx);
    /* */
    int getOtherConstraintResultConIdx(int solIdx, int otherIdx, int conIdx);
    /* */
    std::string getOtherConstraintResultCon(int solIdx, int otherIdx, int conIdx);


    std::string getOtherConstraintResultArrayType(int solIdx,int otherIdx);

    std::string getOtherConstraintResultEnumerationValue(int solIdx,int otherIdx, int enumIdx);

    std::string getOtherConstraintResultEnumerationDescription(int solIdx,int otherIdx, int enumIdx);

    int  getOtherConstraintResultEnumerationNumberOfEl(int solIdx,int otherIdx, int enumIdx);

    int getOtherConstraintResultEnumerationEl(int solIdx,int otherIdx, int enumIdx, int j);

    int getOtherConstraintResultArrayDense(int solIdx, int otherIdx, std::string* resultArray, int dim);



    /* */
    int getNumberOfOtherSolutionResults(int solIdx);
    /* */
    std::string getOtherSolutionResultName(int solIdx, int otherIdx);
    /* */
    std::string getOtherSolutionResultValue(int solIdx, int otherIdx);
    /* */
    std::string getOtherSolutionResultCategory(int solIdx, int otherIdx);
    /* */
    std::string getOtherSolutionResultDescription(int solIdx, int otherIdx);
    /* */
    int getOtherSolutionResultNumberOfItems(int solIdx, int otherIdx);
    /* */
    std::string getOtherSolutionResultItem(int solIdx, int otherIdx, int itemIdx);
    /* */
    int getNumberOfSolverOutputs();
    /* */
    std::string getSolverOutputName(int otherIdx);
    /* */
    std::string getSolverOutputCategory(int otherIdx);
    /* */
    std::string getSolverOutputDescription(int otherIdx);
    /* */
    int getSolverOutputNumberOfItems(int otherIdx);
    /* */
    std::string getSolverOutputItem(int otherIdx, int itemIdx);

    // set() methods
    //

    bool setGeneralStatus(GeneralStatus *status);

    bool setGeneralStatusType(std::string type);

    bool setNumberOfGeneralSubstatuses(int num);

    bool setGeneralStatusDescription(std::string description);

    bool setGeneralSubstatusName(int idx, std::string name);

    bool setGeneralSubstatusDescription(int idx, std::string description);

    bool setGeneralMessage(std::string message);

    bool setServiceName(std::string serviceName);

    bool setServiceURI(std::string serviceURI);

    bool setInstanceName(std::string instanceName);

    bool setJobID(std::string jobID);

    bool setSolverInvoked(std::string solverInvoked);

    bool setTimeStamp(std::string timeStamp);

    bool setNumberOfOtherGeneralResults(int num);

    bool setOtherGeneralResultName(int idx, std::string name);

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

    bool setOtherGeneralResultDescription(int idx, std::string description);

    bool setSystemInformation(std::string systemInformation);

    bool setAvailableDiskSpaceUnit(std::string unit);

    bool setAvailableDiskSpaceDescription(std::string description);

    bool setAvailableDiskSpaceValue(double value);

    bool setAvailableMemoryUnit(std::string unit);

    bool setAvailableMemoryDescription(std::string description);

    bool setAvailableMemoryValue(double value);

    bool setAvailableCPUSpeedUnit(std::string unit);

    bool setAvailableCPUSpeedDescription(std::string description);

    bool setAvailableCPUSpeedValue(double value);

    bool setAvailableCPUNumberDescription(std::string description);

    bool setAvailableCPUNumberValue(int value);

    bool setNumberOfOtherSystemResults(int num);

    bool setOtherSystemResultName(int idx, std::string name);

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

    bool setOtherSystemResultDescription(int idx, std::string description);

    bool setCurrentState(std::string currentState);

    bool setCurrentJobCount(int jobCount);

    bool setTotalJobsSoFar(int number);

    bool setTimeServiceStarted(std::string startTime);

    bool setServiceUtilization(double value);


    bool setNumberOfOtherServiceResults(int num);

    bool setOtherServiceResultName(int idx, std::string name);

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

    bool setOtherServiceResultDescription(int idx, std::string description);


    bool setJobStatus(std::string status);

    bool setJobSubmitTime(std::string submitTime);

    bool setScheduledStartTime(std::string scheduledStartTime);

    bool setActualStartTime(std::string actualStartTime);

    bool setJobEndTime(std::string endTime);


    bool setTime(double time);

    bool addTimingInformation(std::string type, std::string category,
                              std::string unit, std::string description, double value);

    bool setTimingInformation(int idx, std::string type, std::string category,
                              std::string unit, std::string description, double value);

    bool setNumberOfTimes(int numberOfTimes);

    bool setTimeNumber(int timeNumber);

    bool setUsedDiskSpaceUnit(std::string unit);

    bool setUsedDiskSpaceDescription(std::string description);

    bool setUsedDiskSpaceValue(double value);

    bool setUsedMemoryUnit(std::string unit);

    bool setUsedMemoryDescription(std::string description);

    bool setUsedMemoryValue(double value);

    bool setUsedCPUSpeedUnit(std::string unit);

    bool setUsedCPUSpeedDescription(std::string description);

    bool setUsedCPUSpeedValue(double value);

    bool setUsedCPUNumberDescription(std::string description);

    bool setUsedCPUNumberValue(int value);

    bool setNumberOfOtherJobResults(int num);

    bool setOtherJobResultName(int idx, std::string name);

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

    bool setOtherJobResultDescription(int idx, std::string description);


    bool setVariableNumber(int variableNumber);

    bool setObjectiveNumber(int objectiveNumber);

    bool setConstraintNumber(int constraintNumber); 

    bool setSolutionNumber(int number);


    bool setSolutionStatus(int solIdx, std::string type, std::string description);

    bool setSolutionStatusType(int solIdx, std::string type);

    bool setNumberOfSolutionSubstatuses(int solIdx, int num);

    bool setSolutionStatusDescription(int solIdx, std::string description);

    bool setSolutionSubstatusType(int solIdx, int substatusIdx, std::string type);

    bool setSolutionSubstatusDescription(int solIdx, int substatusIdx, std::string description);


    bool setSolutionTargetObjectiveIdx(int solIdx, int objectiveIdx);

    bool setSolutionTargetObjectiveName(int solIdx, std::string objectiveName);

    bool setSolutionWeightedObjectives(int solIdx, bool weightedObjectives);

    bool setSolutionMessage(int solIdx, std::string msg);

    bool setNumberOfPrimalVariableValues(int solIdx, int n);

    bool setPrimalVariableValuesSparse(int solIdx, std::vector<IndexValuePair*> x);

    bool setPrimalVariableValuesDense(int solIdx, double *x);

    bool setNumberOfVarValues(int solIdx, int numberOfVar);

    bool setVarValue(int solIdx, int number, int idx, std::string name, double val);

    bool setNumberOfVarValuesString(int solIdx, int numberOfVar);

    bool setVarValueString(int solIdx, int number, int idx, std::string name, std::string str);


    bool setBasisStatus(int solIdx, int object, int status, int *i, int ni);

    bool setNumberOfOtherVariableResults(int solIdx, int numberOfOtherVariableResults);

    bool setAnOtherVariableResultSparse(int solIdx, int otherIdx, std::string name, std::string value, std::string description, int *idx,  std::string *s, int n);

    bool setAnOtherVariableResultSparse(int solIdx, int otherIdx, std::string name, std::string value, std::string description, int *idx,  std::string *s, int n, std::string type, std::string varType, std::string enumType);

    bool setAnOtherVariableResultDense(int solIdx, int otherIdx, std::string name, std::string value, std::string description, std::string *s);

    bool setAnOtherVariableResultDense(int solIdx, int otherIdx, std::string name, std::string value, std::string description, std::string *s, std::string type, std::string varType, std::string enumType);

    bool setOtherVariableResultNumberOfVar(int solIdx, int otherIdx, int numberOfVar);

    bool setOtherVariableResultNumberOfEnumerations(int solIdx, int otherIdx, int numberOfEnumerations);

    bool setOtherVariableResultName(int solIdx, int otherIdx, std::string name);

    bool setOtherVariableResultType(int solIdx, int otherIdx, std::string type);

    bool setOtherVariableResultVarType(int solIdx, int otherIdx, std::string varType);

    bool setOtherVariableResultEnumType(int solIdx, int otherIdx, std::string enumType);

    bool setOtherVariableResultValue(int solIdx, int otherIdx, std::string value);

    bool setOtherVariableResultDescription(int solIdx, int otherIdx, std::string description);

    bool setOtherVariableResultSolver(int solIdx, int otherIdx, std::string solver);

    bool setOtherVariableResultCategory(int solIdx, int otherIdx, std::string category);

    bool setOtherVariableResultVarIdx(int solIdx, int otherIdx, int varIdx, int idx);

    bool setOtherVariableResultVarName(int solIdx, int otherIdx, int varIdx, std::string name);

    bool setOtherVariableResultVar(int solIdx, int otherIdx, int varIdx, std::string value);

    bool setOtherOptionOrResultEnumeration(int solIdx, int otherIdx, int object, int enumIdx, std::string value, std::string description, int *i, int ni);

    bool setNumberOfOtherObjectiveResults(int solIdx, int numberOfOtherObjectiveResults);

    bool setNumberOfObjValues(int solIdx, int numberOfObj);

    bool setNumberOfObjectiveValues(int solIdx, int n);


    bool setObjectiveValuesSparse(int solIdx, std::vector<IndexValuePair*> x);

    bool setObjectiveValuesDense(int solIdx, double *objectiveValues);

    bool setObjValue(int solIdx, int number, int idx, std::string name, double val);

    bool setOtherObjectiveResultNumberOfObj(int solIdx, int otherIdx, int numberOfObj);

    bool setOtherObjectiveResultNumberOfEnumerations(int solIdx, int otherIdx, int numberOfObj);

    bool setOtherObjectiveResultName(int solIdx, int otherIdx, std::string name);

    bool setOtherObjectiveResultType(int solIdx, int otherIdx, std::string type);

    bool setOtherObjectiveResultObjType(int solIdx, int otherIdx, std::string objType);

    bool setOtherObjectiveResultEnumType(int solIdx, int otherIdx, std::string enumType);

    bool setOtherObjectiveResultValue(int solIdx, int otherIdx, std::string value);

    bool setOtherObjectiveResultDescription(int solIdx, int otherIdx, std::string description);

    bool setOtherObjectiveResultSolver(int solIdx, int otherIdx, std::string solver);

    bool setOtherObjectiveResultCategory(int solIdx, int otherIdx, std::string category);

    bool setOtherObjectiveResultObjIdx(int solIdx, int otherIdx, int objIdx, int idx);

    bool setOtherObjectiveResultObjName(int solIdx, int otherIdx, int objIdx, std::string name);

    bool setOtherObjectiveResultObj(int solIdx, int otherIdx, int objIdx, std::string value);

    bool setNumberOfOtherConstraintResults(int solIdx, int numberOfOtherConstraintResults);

    bool setNumberOfDualValues(int solIdx, int numberOfCon);


    bool setNumberOfDualVariableValues(int solIdx, int n);


    bool setDualVariableValuesSparse(int solIdx, std::vector<IndexValuePair*> x);


    bool setDualVariableValuesDense(int solIdx, double *y);

    bool setConstraintValuesDense(int solIdx, double *constraintValues);

    bool setDualValue(int solIdx, int number, int idx, std::string name, double val);

    bool setOtherConstraintResultNumberOfCon(int solIdx, int otherIdx, int numberOfCon);

    bool setOtherConstraintResultNumberOfEnumerations(int solIdx, int otherIdx, int numberOfCon);

    bool setOtherConstraintResultName(int solIdx, int otherIdx, std::string name);

    bool setOtherConstraintResultType(int solIdx, int otherIdx, std::string type);

    bool setOtherConstraintResultConType(int solIdx, int otherIdx, std::string conType);

    bool setOtherConstraintResultEnumType(int solIdx, int otherIdx, std::string enumType);

    bool setOtherConstraintResultValue(int solIdx, int otherIdx, std::string value);

    bool setOtherConstraintResultDescription(int solIdx, int otherIdx, std::string description);

    bool setOtherConstraintResultSolver(int solIdx, int otherIdx, std::string solver);

    bool setOtherConstraintResultCategory(int solIdx, int otherIdx, std::string category);

    bool setOtherConstraintResultConIdx(int solIdx, int otherIdx, int conIdx, int idx);

    bool setOtherConstraintResultConName(int solIdx, int otherIdx, int conIdx, std::string name);

    bool setOtherConstraintResultCon(int solIdx, int otherIdx, int conIdx, std::string value);

    bool setMatrixVariableSolution(int solIdx, int numberOfMatrixVar_, 
                                               int numberOfOtherMatrixVariableResults_);

    bool setMatrixVarValuesAttributes(int solIdx, int idx, int matrixVarIdx, int numberOfRows, 
            int numberOfColumns, ENUM_MATRIX_SYMMETRY symmetry=ENUM_MATRIX_SYMMETRY_none, 
            ENUM_MATRIX_TYPE type=ENUM_MATRIX_TYPE_unknown, std::string name="");

    bool setMatrixVarValuesBlockStructure(int solIdx, int idx, int* colOffset, int colOffsetSize,
            int* rowOffset, int rowOffsetSize, int numberOfBlocks, int blocksConstructorIdx=0);

    bool setMatrixVarValuesBlockElements(int solIdx, int idx, int blkno, int blkRowIdx, int blkColIdx,
            int nz, int* start, int* index, MatrixElementValues* value, ENUM_MATRIX_TYPE valueType,
            ENUM_MATRIX_SYMMETRY symmetry=ENUM_MATRIX_SYMMETRY_none, bool rowMajor=false);

    bool setMatrixVariablesOtherResultGeneralAttributes(int solIdx, int idx, std::string name, 
                            std::string description, std::string value, std::string type,
                            std::string solver, std::string category,
                            int numberOfMatrixVar=0,    std::string matrixType="", 
                            int numberOfEnumerations=0, std::string enumType="");

    bool setMatrixVariablesOtherResultMatrixAttributes(int solIdx, int otherIdx, int matrixVarIdx, 
            int numberOfRows, int numberOfColumns, 
            ENUM_MATRIX_SYMMETRY symmetry=ENUM_MATRIX_SYMMETRY_none, 
            ENUM_MATRIX_TYPE type=ENUM_MATRIX_TYPE_unknown, std::string name="");

    bool setMatrixVariablesOtherResultBlockStructure(int solIdx, int otherIdx, int matrixVarIdx, 
            int* colOffset, int colOffsetSize, int* rowOffset, int rowOffsetSize, 
            int numberOfBlocks, int blocksConstructorIdx=0);

    bool setMatrixVariablesOtherResultBlockElements(int solIdx, int otherIdx, int matrixVarIdx, 
            int blkno, int blkRowIdx, int blkColIdx, int nz, int* start, int* index,
            MatrixElementValues* value, ENUM_MATRIX_TYPE valueType,
            ENUM_MATRIX_SYMMETRY symmetry=ENUM_MATRIX_SYMMETRY_none, bool rowMajor=false);

    bool setNumberOfOtherSolutionResults(int solIdx, int numberOfOtherSolutionResults);

    bool setOtherSolutionResultName(int solIdx, int otherIdx, std::string name);

    bool setOtherSolutionResultValue(int solIdx, int otherIdx, std::string value);

    bool setOtherSolutionResultCategory(int solIdx, int otherIdx, std::string category);

    bool setOtherSolutionResultDescription(int solIdx, int otherIdx, std::string description);

    bool setOtherSolutionResultNumberOfItems(int solIdx, int otherIdx, int numberOfItems);

    bool setOtherSolutionResultItem(int solIdx, int otherIdx, int itemIdx, std::string item);

    bool setAnOtherSolutionResult(int solIdx, std::string name, std::string value, std::string category, 
        std::string description, int numberOfItems, std::string* item);

    bool setNumberOfSolverOutputs(int numberOfSolverOutputs);

    bool setSolverOutputName(int otherIdx, std::string name);

    bool setSolverOutputCategory(int otherIdx, std::string category);

    bool setSolverOutputDescription(int otherIdx, std::string description);

    bool setSolverOutputNumberOfItems(int otherIdx, int numberOfItems);

    bool setSolverOutputItem(int otherIdx, int itemIdx, std::string item);


};
#endif