ModelBuilderHelper.cs

Go to the documentation of this file.

//------------------------------------------------------------------------------
// <auto-generated />
//
// This file was automatically generated by SWIG (https://www.swig.org).
// Version 4.2.1
//
// Do not make changes to this file unless you know what you are doing - modify
// the SWIG interface file instead.
//------------------------------------------------------------------------------
 
namespace Google.OrTools.ModelBuilder {
 
public class ModelBuilderHelper : global::System.IDisposable {
  private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  protected bool swigCMemOwn;
 
  internal ModelBuilderHelper(global::System.IntPtr cPtr, bool cMemoryOwn) {
    swigCMemOwn = cMemoryOwn;
    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
  }
 
  internal static global::System.Runtime.InteropServices.HandleRef getCPtr(ModelBuilderHelper obj) {
    return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  }
 
  internal static global::System.Runtime.InteropServices.HandleRef swigRelease(ModelBuilderHelper obj) {
    if (obj != null) {
      if (!obj.swigCMemOwn)
        throw new global::System.ApplicationException("Cannot release ownership as memory is not owned");
      global::System.Runtime.InteropServices.HandleRef ptr = obj.swigCPtr;
      obj.swigCMemOwn = false;
      obj.Dispose();
      return ptr;
    } else {
      return new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
    }
  }
 
  ~ModelBuilderHelper() {
    Dispose(false);
  }
 
  public void Dispose() {
    Dispose(true);
    global::System.GC.SuppressFinalize(this);
  }
 
  protected virtual void Dispose(bool disposing) {
    lock(this) {
      if (swigCPtr.Handle != global::System.IntPtr.Zero) {
        if (swigCMemOwn) {
          swigCMemOwn = false;
          operations_research_model_builderPINVOKE.delete_ModelBuilderHelper(swigCPtr);
        }
        swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
      }
    }
  }
 
  public void OverwriteModel(ModelBuilderHelper other_helper) {
    operations_research_model_builderPINVOKE.ModelBuilderHelper_OverwriteModel(swigCPtr, ModelBuilderHelper.getCPtr(other_helper));
    if (operations_research_model_builderPINVOKE.SWIGPendingException.Pending) throw operations_research_model_builderPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool ReadModelFromProtoFile(string filename) {
    bool ret = operations_research_model_builderPINVOKE.ModelBuilderHelper_ReadModelFromProtoFile(swigCPtr, filename);
    if (operations_research_model_builderPINVOKE.SWIGPendingException.Pending) throw operations_research_model_builderPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public bool WriteModelToProtoFile(string filename) {
    bool ret = operations_research_model_builderPINVOKE.ModelBuilderHelper_WriteModelToProtoFile(swigCPtr, filename);
    if (operations_research_model_builderPINVOKE.SWIGPendingException.Pending) throw operations_research_model_builderPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public bool ImportFromMpsString(string mps_string) {
    bool ret = operations_research_model_builderPINVOKE.ModelBuilderHelper_ImportFromMpsString(swigCPtr, mps_string);
    if (operations_research_model_builderPINVOKE.SWIGPendingException.Pending) throw operations_research_model_builderPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public bool ImportFromMpsFile(string mps_file) {
    bool ret = operations_research_model_builderPINVOKE.ModelBuilderHelper_ImportFromMpsFile(swigCPtr, mps_file);
    if (operations_research_model_builderPINVOKE.SWIGPendingException.Pending) throw operations_research_model_builderPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public bool ImportFromLpString(string lp_string) {
    bool ret = operations_research_model_builderPINVOKE.ModelBuilderHelper_ImportFromLpString(swigCPtr, lp_string);
    if (operations_research_model_builderPINVOKE.SWIGPendingException.Pending) throw operations_research_model_builderPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public bool ImportFromLpFile(string lp_file) {
    bool ret = operations_research_model_builderPINVOKE.ModelBuilderHelper_ImportFromLpFile(swigCPtr, lp_file);
    if (operations_research_model_builderPINVOKE.SWIGPendingException.Pending) throw operations_research_model_builderPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public int AddVar() {
    int ret = operations_research_model_builderPINVOKE.ModelBuilderHelper_AddVar(swigCPtr);
    return ret;
  }
 
  public void SetVarLowerBound(int var_index, double lb) {
    operations_research_model_builderPINVOKE.ModelBuilderHelper_SetVarLowerBound(swigCPtr, var_index, lb);
  }
 
  public void SetVarUpperBound(int var_index, double ub) {
    operations_research_model_builderPINVOKE.ModelBuilderHelper_SetVarUpperBound(swigCPtr, var_index, ub);
  }
 
  public void SetVarIntegrality(int var_index, bool is_integer) {
    operations_research_model_builderPINVOKE.ModelBuilderHelper_SetVarIntegrality(swigCPtr, var_index, is_integer);
  }
 
  public void SetVarObjectiveCoefficient(int var_index, double coeff) {
    operations_research_model_builderPINVOKE.ModelBuilderHelper_SetVarObjectiveCoefficient(swigCPtr, var_index, coeff);
  }
 
  public void SetVarName(int var_index, string name) {
    operations_research_model_builderPINVOKE.ModelBuilderHelper_SetVarName(swigCPtr, var_index, name);
    if (operations_research_model_builderPINVOKE.SWIGPendingException.Pending) throw operations_research_model_builderPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public double VarLowerBound(int var_index) {
    double ret = operations_research_model_builderPINVOKE.ModelBuilderHelper_VarLowerBound(swigCPtr, var_index);
    return ret;
  }
 
  public double VarUpperBound(int var_index) {
    double ret = operations_research_model_builderPINVOKE.ModelBuilderHelper_VarUpperBound(swigCPtr, var_index);
    return ret;
  }
 
  public bool VarIsIntegral(int var_index) {
    bool ret = operations_research_model_builderPINVOKE.ModelBuilderHelper_VarIsIntegral(swigCPtr, var_index);
    return ret;
  }
 
  public double VarObjectiveCoefficient(int var_index) {
    double ret = operations_research_model_builderPINVOKE.ModelBuilderHelper_VarObjectiveCoefficient(swigCPtr, var_index);
    return ret;
  }
 
  public string VarName(int var_index) {
    string ret = operations_research_model_builderPINVOKE.ModelBuilderHelper_VarName(swigCPtr, var_index);
    return ret;
  }
 
  public double ConstraintLowerBound(int ct_index) {
    double ret = operations_research_model_builderPINVOKE.ModelBuilderHelper_ConstraintLowerBound(swigCPtr, ct_index);
    return ret;
  }
 
  public double ConstraintUpperBound(int ct_index) {
    double ret = operations_research_model_builderPINVOKE.ModelBuilderHelper_ConstraintUpperBound(swigCPtr, ct_index);
    return ret;
  }
 
  public int AddLinearConstraint() {
    int ret = operations_research_model_builderPINVOKE.ModelBuilderHelper_AddLinearConstraint(swigCPtr);
    return ret;
  }
 
  public string ConstraintName(int ct_index) {
    string ret = operations_research_model_builderPINVOKE.ModelBuilderHelper_ConstraintName(swigCPtr, ct_index);
    return ret;
  }
 
  public  double[]  ConstraintCoefficients(int ct_index) {
  global::System.IntPtr cPtr = operations_research_model_builderPINVOKE.ModelBuilderHelper_ConstraintCoefficients(swigCPtr, ct_index);
  DoubleVector tmpVector = null;
  if (cPtr != global::System.IntPtr.Zero) {
    tmpVector = new DoubleVector(cPtr, true);
    double[] outArray = new double[tmpVector.Count];
    tmpVector.CopyTo(outArray);
    return outArray;
  }
  return null;
}
 
  public  int[]  ConstraintVarIndices(int ct_index) {
  global::System.IntPtr cPtr = operations_research_model_builderPINVOKE.ModelBuilderHelper_ConstraintVarIndices(swigCPtr, ct_index);
  IntVector tmpVector = null;
  if (cPtr != global::System.IntPtr.Zero) {
    tmpVector = new IntVector(cPtr, true);
    int[] outArray = new int[tmpVector.Count];
    tmpVector.CopyTo(outArray);
    return outArray;
  }
  return null;
}
 
  public void AddConstraintTerm(int ct_index, int var_index, double coeff) {
    operations_research_model_builderPINVOKE.ModelBuilderHelper_AddConstraintTerm(swigCPtr, ct_index, var_index, coeff);
  }
 
  public void ClearConstraintTerms(int ct_index) {
    operations_research_model_builderPINVOKE.ModelBuilderHelper_ClearConstraintTerms(swigCPtr, ct_index);
  }
 
  public void SafeAddConstraintTerm(int ct_index, int var_index, double coeff) {
    operations_research_model_builderPINVOKE.ModelBuilderHelper_SafeAddConstraintTerm(swigCPtr, ct_index, var_index, coeff);
  }
 
  public void SetConstraintCoefficient(int ct_index, int var_index, double coeff) {
    operations_research_model_builderPINVOKE.ModelBuilderHelper_SetConstraintCoefficient(swigCPtr, ct_index, var_index, coeff);
  }
 
  public void SetConstraintLowerBound(int ct_index, double lb) {
    operations_research_model_builderPINVOKE.ModelBuilderHelper_SetConstraintLowerBound(swigCPtr, ct_index, lb);
  }
 
  public void SetConstraintName(int ct_index, string name) {
    operations_research_model_builderPINVOKE.ModelBuilderHelper_SetConstraintName(swigCPtr, ct_index, name);
    if (operations_research_model_builderPINVOKE.SWIGPendingException.Pending) throw operations_research_model_builderPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public void SetConstraintUpperBound(int ct_index, double ub) {
    operations_research_model_builderPINVOKE.ModelBuilderHelper_SetConstraintUpperBound(swigCPtr, ct_index, ub);
  }
 
  public bool EnforcedIndicatorValue(int ct_index) {
    bool ret = operations_research_model_builderPINVOKE.ModelBuilderHelper_EnforcedIndicatorValue(swigCPtr, ct_index);
    return ret;
  }
 
  public bool IsEnforcedConstraint(int ct_index) {
    bool ret = operations_research_model_builderPINVOKE.ModelBuilderHelper_IsEnforcedConstraint(swigCPtr, ct_index);
    return ret;
  }
 
  public double EnforcedConstraintLowerBound(int ct_index) {
    double ret = operations_research_model_builderPINVOKE.ModelBuilderHelper_EnforcedConstraintLowerBound(swigCPtr, ct_index);
    return ret;
  }
 
  public double EnforcedConstraintUpperBound(int ct_index) {
    double ret = operations_research_model_builderPINVOKE.ModelBuilderHelper_EnforcedConstraintUpperBound(swigCPtr, ct_index);
    return ret;
  }
 
  public int AddEnforcedLinearConstraint() {
    int ret = operations_research_model_builderPINVOKE.ModelBuilderHelper_AddEnforcedLinearConstraint(swigCPtr);
    return ret;
  }
 
  public int EnforcedIndicatorVariableIndex(int ct_index) {
    int ret = operations_research_model_builderPINVOKE.ModelBuilderHelper_EnforcedIndicatorVariableIndex(swigCPtr, ct_index);
    return ret;
  }
 
  public string EnforcedConstraintName(int ct_index) {
    string ret = operations_research_model_builderPINVOKE.ModelBuilderHelper_EnforcedConstraintName(swigCPtr, ct_index);
    return ret;
  }
 
  public  double[]  EnforcedConstraintCoefficients(int ct_index) {
  global::System.IntPtr cPtr = operations_research_model_builderPINVOKE.ModelBuilderHelper_EnforcedConstraintCoefficients(swigCPtr, ct_index);
  DoubleVector tmpVector = null;
  if (cPtr != global::System.IntPtr.Zero) {
    tmpVector = new DoubleVector(cPtr, true);
    double[] outArray = new double[tmpVector.Count];
    tmpVector.CopyTo(outArray);
    return outArray;
  }
  return null;
}
 
  public  int[]  EnforcedConstraintVarIndices(int ct_index) {
  global::System.IntPtr cPtr = operations_research_model_builderPINVOKE.ModelBuilderHelper_EnforcedConstraintVarIndices(swigCPtr, ct_index);
  IntVector tmpVector = null;
  if (cPtr != global::System.IntPtr.Zero) {
    tmpVector = new IntVector(cPtr, true);
    int[] outArray = new int[tmpVector.Count];
    tmpVector.CopyTo(outArray);
    return outArray;
  }
  return null;
}
 
  public void AddEnforcedConstraintTerm(int ct_index, int var_index, double coeff) {
    operations_research_model_builderPINVOKE.ModelBuilderHelper_AddEnforcedConstraintTerm(swigCPtr, ct_index, var_index, coeff);
  }
 
  public void ClearEnforcedConstraintTerms(int ct_index) {
    operations_research_model_builderPINVOKE.ModelBuilderHelper_ClearEnforcedConstraintTerms(swigCPtr, ct_index);
  }
 
  public void SafeAddEnforcedConstraintTerm(int ct_index, int var_index, double coeff) {
    operations_research_model_builderPINVOKE.ModelBuilderHelper_SafeAddEnforcedConstraintTerm(swigCPtr, ct_index, var_index, coeff);
  }
 
  public void SetEnforcedConstraintCoefficient(int ct_index, int var_index, double coeff) {
    operations_research_model_builderPINVOKE.ModelBuilderHelper_SetEnforcedConstraintCoefficient(swigCPtr, ct_index, var_index, coeff);
  }
 
  public void SetEnforcedConstraintLowerBound(int ct_index, double lb) {
    operations_research_model_builderPINVOKE.ModelBuilderHelper_SetEnforcedConstraintLowerBound(swigCPtr, ct_index, lb);
  }
 
  public void SetEnforcedConstraintName(int ct_index, string name) {
    operations_research_model_builderPINVOKE.ModelBuilderHelper_SetEnforcedConstraintName(swigCPtr, ct_index, name);
    if (operations_research_model_builderPINVOKE.SWIGPendingException.Pending) throw operations_research_model_builderPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public void SetEnforcedConstraintUpperBound(int ct_index, double ub) {
    operations_research_model_builderPINVOKE.ModelBuilderHelper_SetEnforcedConstraintUpperBound(swigCPtr, ct_index, ub);
  }
 
  public void SetEnforcedIndicatorValue(int ct_index, bool positive) {
    operations_research_model_builderPINVOKE.ModelBuilderHelper_SetEnforcedIndicatorValue(swigCPtr, ct_index, positive);
  }
 
  public void SetEnforcedIndicatorVariableIndex(int ct_index, int var_index) {
    operations_research_model_builderPINVOKE.ModelBuilderHelper_SetEnforcedIndicatorVariableIndex(swigCPtr, ct_index, var_index);
  }
 
  public int ConstraintsCount() {
    int ret = operations_research_model_builderPINVOKE.ModelBuilderHelper_ConstraintsCount(swigCPtr);
    return ret;
  }
 
  public int VariablesCount() {
    int ret = operations_research_model_builderPINVOKE.ModelBuilderHelper_VariablesCount(swigCPtr);
    return ret;
  }
 
  public string Name() {
    string ret = operations_research_model_builderPINVOKE.ModelBuilderHelper_Name(swigCPtr);
    return ret;
  }
 
  public void SetName(string name) {
    operations_research_model_builderPINVOKE.ModelBuilderHelper_SetName(swigCPtr, name);
    if (operations_research_model_builderPINVOKE.SWIGPendingException.Pending) throw operations_research_model_builderPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public void ClearObjective() {
    operations_research_model_builderPINVOKE.ModelBuilderHelper_ClearObjective(swigCPtr);
  }
 
  public bool Maximize() {
    bool ret = operations_research_model_builderPINVOKE.ModelBuilderHelper_Maximize(swigCPtr);
    return ret;
  }
 
  public void SetMaximize(bool maximize) {
    operations_research_model_builderPINVOKE.ModelBuilderHelper_SetMaximize(swigCPtr, maximize);
  }
 
  public double ObjectiveOffset() {
    double ret = operations_research_model_builderPINVOKE.ModelBuilderHelper_ObjectiveOffset(swigCPtr);
    return ret;
  }
 
  public void SetObjectiveOffset(double offset) {
    operations_research_model_builderPINVOKE.ModelBuilderHelper_SetObjectiveOffset(swigCPtr, offset);
  }
 
  public void ClearHints() {
    operations_research_model_builderPINVOKE.ModelBuilderHelper_ClearHints(swigCPtr);
  }
 
  public void AddHint(int var_index, double var_value) {
    operations_research_model_builderPINVOKE.ModelBuilderHelper_AddHint(swigCPtr, var_index, var_value);
  }
 
  public string ExportToMpsString(bool obfuscate) {
    string ret = operations_research_model_builderPINVOKE.ModelBuilderHelper_ExportToMpsString(swigCPtr, obfuscate);
    return ret;
  }
 
  public string ExportToLpString(bool obfuscate) {
    string ret = operations_research_model_builderPINVOKE.ModelBuilderHelper_ExportToLpString(swigCPtr, obfuscate);
    return ret;
  }
 
  public bool WriteToMpsFile(string filename, bool obfuscate) {
    bool ret = operations_research_model_builderPINVOKE.ModelBuilderHelper_WriteToMpsFile(swigCPtr, filename, obfuscate);
    if (operations_research_model_builderPINVOKE.SWIGPendingException.Pending) throw operations_research_model_builderPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public ModelBuilderHelper() : this(operations_research_model_builderPINVOKE.new_ModelBuilderHelper(), true) {
  }
 
}
 
}