ModelCache.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.ConstraintSolver {
 
using System;
using System.Runtime.InteropServices;
using System.Collections;
using System.Collections.Generic;
 
public partial class ModelCache : global::System.IDisposable {
  private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  protected bool swigCMemOwn;
 
  internal ModelCache(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(ModelCache 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(ModelCache 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);
    }
  }
 
  ~ModelCache() {
    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_constraint_solverPINVOKE.delete_ModelCache(swigCPtr);
        }
        swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
      }
    }
  }
 
  public virtual void Clear() {
    operations_research_constraint_solverPINVOKE.ModelCache_Clear(swigCPtr);
  }
 
  public virtual Constraint FindVoidConstraint(int type) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.ModelCache_FindVoidConstraint(swigCPtr, type);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public virtual void InsertVoidConstraint(Constraint ct, int type) {
    operations_research_constraint_solverPINVOKE.ModelCache_InsertVoidConstraint(swigCPtr, Constraint.getCPtr(ct), type);
  }
 
  public virtual Constraint FindVarConstantConstraint(IntVar var, long value, int type) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.ModelCache_FindVarConstantConstraint(swigCPtr, IntVar.getCPtr(var), value, type);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public virtual void InsertVarConstantConstraint(Constraint ct, IntVar var, long value, int type) {
    operations_research_constraint_solverPINVOKE.ModelCache_InsertVarConstantConstraint(swigCPtr, Constraint.getCPtr(ct), IntVar.getCPtr(var), value, type);
  }
 
  public virtual Constraint FindVarConstantConstantConstraint(IntVar var, long value1, long value2, int type) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.ModelCache_FindVarConstantConstantConstraint(swigCPtr, IntVar.getCPtr(var), value1, value2, type);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public virtual void InsertVarConstantConstantConstraint(Constraint ct, IntVar var, long value1, long value2, int type) {
    operations_research_constraint_solverPINVOKE.ModelCache_InsertVarConstantConstantConstraint(swigCPtr, Constraint.getCPtr(ct), IntVar.getCPtr(var), value1, value2, type);
  }
 
  public virtual Constraint FindExprExprConstraint(IntExpr expr1, IntExpr expr2, int type) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.ModelCache_FindExprExprConstraint(swigCPtr, IntExpr.getCPtr(expr1), IntExpr.getCPtr(expr2), type);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public virtual void InsertExprExprConstraint(Constraint ct, IntExpr expr1, IntExpr expr2, int type) {
    operations_research_constraint_solverPINVOKE.ModelCache_InsertExprExprConstraint(swigCPtr, Constraint.getCPtr(ct), IntExpr.getCPtr(expr1), IntExpr.getCPtr(expr2), type);
  }
 
  public virtual IntExpr FindExprExpression(IntExpr expr, int type) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.ModelCache_FindExprExpression(swigCPtr, IntExpr.getCPtr(expr), type);
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    return ret;
  }
 
  public virtual void InsertExprExpression(IntExpr expression, IntExpr expr, int type) {
    operations_research_constraint_solverPINVOKE.ModelCache_InsertExprExpression(swigCPtr, IntExpr.getCPtr(expression), IntExpr.getCPtr(expr), type);
  }
 
  public virtual IntExpr FindExprConstantExpression(IntExpr expr, long value, int type) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.ModelCache_FindExprConstantExpression(swigCPtr, IntExpr.getCPtr(expr), value, type);
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    return ret;
  }
 
  public virtual void InsertExprConstantExpression(IntExpr expression, IntExpr var, long value, int type) {
    operations_research_constraint_solverPINVOKE.ModelCache_InsertExprConstantExpression(swigCPtr, IntExpr.getCPtr(expression), IntExpr.getCPtr(var), value, type);
  }
 
  public virtual IntExpr FindExprExprExpression(IntExpr var1, IntExpr var2, int type) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.ModelCache_FindExprExprExpression(swigCPtr, IntExpr.getCPtr(var1), IntExpr.getCPtr(var2), type);
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    return ret;
  }
 
  public virtual void InsertExprExprExpression(IntExpr expression, IntExpr var1, IntExpr var2, int type) {
    operations_research_constraint_solverPINVOKE.ModelCache_InsertExprExprExpression(swigCPtr, IntExpr.getCPtr(expression), IntExpr.getCPtr(var1), IntExpr.getCPtr(var2), type);
  }
 
  public virtual IntExpr FindExprExprConstantExpression(IntExpr var1, IntExpr var2, long constant, int type) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.ModelCache_FindExprExprConstantExpression(swigCPtr, IntExpr.getCPtr(var1), IntExpr.getCPtr(var2), constant, type);
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    return ret;
  }
 
  public virtual void InsertExprExprConstantExpression(IntExpr expression, IntExpr var1, IntExpr var2, long constant, int type) {
    operations_research_constraint_solverPINVOKE.ModelCache_InsertExprExprConstantExpression(swigCPtr, IntExpr.getCPtr(expression), IntExpr.getCPtr(var1), IntExpr.getCPtr(var2), constant, type);
  }
 
  public virtual IntExpr FindVarConstantConstantExpression(IntVar var, long value1, long value2, int type) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.ModelCache_FindVarConstantConstantExpression(swigCPtr, IntVar.getCPtr(var), value1, value2, type);
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    return ret;
  }
 
  public virtual void InsertVarConstantConstantExpression(IntExpr expression, IntVar var, long value1, long value2, int type) {
    operations_research_constraint_solverPINVOKE.ModelCache_InsertVarConstantConstantExpression(swigCPtr, IntExpr.getCPtr(expression), IntVar.getCPtr(var), value1, value2, type);
  }
 
  public virtual IntExpr FindVarConstantArrayExpression(IntVar var,  long[]  values, int type) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.ModelCache_FindVarConstantArrayExpression(swigCPtr, IntVar.getCPtr(var),  values.Length, values , type);
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    return ret;
  }
 
  public virtual void InsertVarConstantArrayExpression(IntExpr expression, IntVar var,  long[]  values, int type) {
    operations_research_constraint_solverPINVOKE.ModelCache_InsertVarConstantArrayExpression(swigCPtr, IntExpr.getCPtr(expression), IntVar.getCPtr(var),  values.Length, values , type);
  }
 
  public virtual IntExpr FindVarArrayExpression(IntVarVector vars, int type) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.ModelCache_FindVarArrayExpression(swigCPtr, IntVarVector.getCPtr(vars), type);
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void InsertVarArrayExpression(IntExpr expression, IntVarVector vars, int type) {
    operations_research_constraint_solverPINVOKE.ModelCache_InsertVarArrayExpression(swigCPtr, IntExpr.getCPtr(expression), IntVarVector.getCPtr(vars), type);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual IntExpr FindVarArrayConstantArrayExpression(IntVarVector vars,  long[]  values, int type) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.ModelCache_FindVarArrayConstantArrayExpression(swigCPtr, IntVarVector.getCPtr(vars),  values.Length, values , type);
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void InsertVarArrayConstantArrayExpression(IntExpr expression, IntVarVector var,  long[]  values, int type) {
    operations_research_constraint_solverPINVOKE.ModelCache_InsertVarArrayConstantArrayExpression(swigCPtr, IntExpr.getCPtr(expression), IntVarVector.getCPtr(var),  values.Length, values , type);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual IntExpr FindVarArrayConstantExpression(IntVarVector vars, long value, int type) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.ModelCache_FindVarArrayConstantExpression(swigCPtr, IntVarVector.getCPtr(vars), value, type);
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void InsertVarArrayConstantExpression(IntExpr expression, IntVarVector var, long value, int type) {
    operations_research_constraint_solverPINVOKE.ModelCache_InsertVarArrayConstantExpression(swigCPtr, IntExpr.getCPtr(expression), IntVarVector.getCPtr(var), value, type);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public Solver solver() {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.ModelCache_solver(swigCPtr);
    Solver ret = (cPtr == global::System.IntPtr.Zero) ? null : new Solver(cPtr, false);
    return ret;
  }
 
  // VoidConstraintType 
  public static readonly int VOID_FALSE_CONSTRAINT = operations_research_constraint_solverPINVOKE.ModelCache_VOID_FALSE_CONSTRAINT_get();
  public static readonly int VOID_TRUE_CONSTRAINT = operations_research_constraint_solverPINVOKE.ModelCache_VOID_TRUE_CONSTRAINT_get();
  public static readonly int VOID_CONSTRAINT_MAX = operations_research_constraint_solverPINVOKE.ModelCache_VOID_CONSTRAINT_MAX_get();
 
  // VarConstantConstraintType 
  public static readonly int VAR_CONSTANT_EQUALITY = operations_research_constraint_solverPINVOKE.ModelCache_VAR_CONSTANT_EQUALITY_get();
  public static readonly int VAR_CONSTANT_GREATER_OR_EQUAL = operations_research_constraint_solverPINVOKE.ModelCache_VAR_CONSTANT_GREATER_OR_EQUAL_get();
  public static readonly int VAR_CONSTANT_LESS_OR_EQUAL = operations_research_constraint_solverPINVOKE.ModelCache_VAR_CONSTANT_LESS_OR_EQUAL_get();
  public static readonly int VAR_CONSTANT_NON_EQUALITY = operations_research_constraint_solverPINVOKE.ModelCache_VAR_CONSTANT_NON_EQUALITY_get();
  public static readonly int VAR_CONSTANT_CONSTRAINT_MAX = operations_research_constraint_solverPINVOKE.ModelCache_VAR_CONSTANT_CONSTRAINT_MAX_get();
 
  // VarConstantConstantConstraintType 
  public static readonly int VAR_CONSTANT_CONSTANT_BETWEEN = operations_research_constraint_solverPINVOKE.ModelCache_VAR_CONSTANT_CONSTANT_BETWEEN_get();
  public static readonly int VAR_CONSTANT_CONSTANT_CONSTRAINT_MAX = operations_research_constraint_solverPINVOKE.ModelCache_VAR_CONSTANT_CONSTANT_CONSTRAINT_MAX_get();
 
  // ExprExprConstraintType 
  public static readonly int EXPR_EXPR_EQUALITY = operations_research_constraint_solverPINVOKE.ModelCache_EXPR_EXPR_EQUALITY_get();
  public static readonly int EXPR_EXPR_GREATER = operations_research_constraint_solverPINVOKE.ModelCache_EXPR_EXPR_GREATER_get();
  public static readonly int EXPR_EXPR_GREATER_OR_EQUAL = operations_research_constraint_solverPINVOKE.ModelCache_EXPR_EXPR_GREATER_OR_EQUAL_get();
  public static readonly int EXPR_EXPR_LESS = operations_research_constraint_solverPINVOKE.ModelCache_EXPR_EXPR_LESS_get();
  public static readonly int EXPR_EXPR_LESS_OR_EQUAL = operations_research_constraint_solverPINVOKE.ModelCache_EXPR_EXPR_LESS_OR_EQUAL_get();
  public static readonly int EXPR_EXPR_NON_EQUALITY = operations_research_constraint_solverPINVOKE.ModelCache_EXPR_EXPR_NON_EQUALITY_get();
  public static readonly int EXPR_EXPR_CONSTRAINT_MAX = operations_research_constraint_solverPINVOKE.ModelCache_EXPR_EXPR_CONSTRAINT_MAX_get();
 
  // ExprExpressionType 
  public static readonly int EXPR_OPPOSITE = operations_research_constraint_solverPINVOKE.ModelCache_EXPR_OPPOSITE_get();
  public static readonly int EXPR_ABS = operations_research_constraint_solverPINVOKE.ModelCache_EXPR_ABS_get();
  public static readonly int EXPR_SQUARE = operations_research_constraint_solverPINVOKE.ModelCache_EXPR_SQUARE_get();
  public static readonly int EXPR_EXPRESSION_MAX = operations_research_constraint_solverPINVOKE.ModelCache_EXPR_EXPRESSION_MAX_get();
 
  // ExprExprExpressionType 
  public static readonly int EXPR_EXPR_DIFFERENCE = operations_research_constraint_solverPINVOKE.ModelCache_EXPR_EXPR_DIFFERENCE_get();
  public static readonly int EXPR_EXPR_PROD = operations_research_constraint_solverPINVOKE.ModelCache_EXPR_EXPR_PROD_get();
  public static readonly int EXPR_EXPR_DIV = operations_research_constraint_solverPINVOKE.ModelCache_EXPR_EXPR_DIV_get();
  public static readonly int EXPR_EXPR_MAX = operations_research_constraint_solverPINVOKE.ModelCache_EXPR_EXPR_MAX_get();
  public static readonly int EXPR_EXPR_MIN = operations_research_constraint_solverPINVOKE.ModelCache_EXPR_EXPR_MIN_get();
  public static readonly int EXPR_EXPR_SUM = operations_research_constraint_solverPINVOKE.ModelCache_EXPR_EXPR_SUM_get();
  public static readonly int EXPR_EXPR_IS_LESS = operations_research_constraint_solverPINVOKE.ModelCache_EXPR_EXPR_IS_LESS_get();
  public static readonly int EXPR_EXPR_IS_LESS_OR_EQUAL = operations_research_constraint_solverPINVOKE.ModelCache_EXPR_EXPR_IS_LESS_OR_EQUAL_get();
  public static readonly int EXPR_EXPR_IS_EQUAL = operations_research_constraint_solverPINVOKE.ModelCache_EXPR_EXPR_IS_EQUAL_get();
  public static readonly int EXPR_EXPR_IS_NOT_EQUAL = operations_research_constraint_solverPINVOKE.ModelCache_EXPR_EXPR_IS_NOT_EQUAL_get();
  public static readonly int EXPR_EXPR_EXPRESSION_MAX = operations_research_constraint_solverPINVOKE.ModelCache_EXPR_EXPR_EXPRESSION_MAX_get();
 
  // ExprExprConstantExpressionType 
  public static readonly int EXPR_EXPR_CONSTANT_CONDITIONAL = operations_research_constraint_solverPINVOKE.ModelCache_EXPR_EXPR_CONSTANT_CONDITIONAL_get();
  public static readonly int EXPR_EXPR_CONSTANT_EXPRESSION_MAX = operations_research_constraint_solverPINVOKE.ModelCache_EXPR_EXPR_CONSTANT_EXPRESSION_MAX_get();
 
  // ExprConstantExpressionType 
  public static readonly int EXPR_CONSTANT_DIFFERENCE = operations_research_constraint_solverPINVOKE.ModelCache_EXPR_CONSTANT_DIFFERENCE_get();
  public static readonly int EXPR_CONSTANT_DIVIDE = operations_research_constraint_solverPINVOKE.ModelCache_EXPR_CONSTANT_DIVIDE_get();
  public static readonly int EXPR_CONSTANT_PROD = operations_research_constraint_solverPINVOKE.ModelCache_EXPR_CONSTANT_PROD_get();
  public static readonly int EXPR_CONSTANT_MAX = operations_research_constraint_solverPINVOKE.ModelCache_EXPR_CONSTANT_MAX_get();
  public static readonly int EXPR_CONSTANT_MIN = operations_research_constraint_solverPINVOKE.ModelCache_EXPR_CONSTANT_MIN_get();
  public static readonly int EXPR_CONSTANT_SUM = operations_research_constraint_solverPINVOKE.ModelCache_EXPR_CONSTANT_SUM_get();
  public static readonly int EXPR_CONSTANT_IS_EQUAL = operations_research_constraint_solverPINVOKE.ModelCache_EXPR_CONSTANT_IS_EQUAL_get();
  public static readonly int EXPR_CONSTANT_IS_NOT_EQUAL = operations_research_constraint_solverPINVOKE.ModelCache_EXPR_CONSTANT_IS_NOT_EQUAL_get();
  public static readonly int EXPR_CONSTANT_IS_GREATER_OR_EQUAL = operations_research_constraint_solverPINVOKE.ModelCache_EXPR_CONSTANT_IS_GREATER_OR_EQUAL_get();
  public static readonly int EXPR_CONSTANT_IS_LESS_OR_EQUAL = operations_research_constraint_solverPINVOKE.ModelCache_EXPR_CONSTANT_IS_LESS_OR_EQUAL_get();
  public static readonly int EXPR_CONSTANT_EXPRESSION_MAX = operations_research_constraint_solverPINVOKE.ModelCache_EXPR_CONSTANT_EXPRESSION_MAX_get();
 
  // VarConstantConstantExpressionType 
  public static readonly int VAR_CONSTANT_CONSTANT_SEMI_CONTINUOUS = operations_research_constraint_solverPINVOKE.ModelCache_VAR_CONSTANT_CONSTANT_SEMI_CONTINUOUS_get();
  public static readonly int VAR_CONSTANT_CONSTANT_EXPRESSION_MAX = operations_research_constraint_solverPINVOKE.ModelCache_VAR_CONSTANT_CONSTANT_EXPRESSION_MAX_get();
 
  // VarConstantArrayExpressionType 
  public static readonly int VAR_CONSTANT_ARRAY_ELEMENT = operations_research_constraint_solverPINVOKE.ModelCache_VAR_CONSTANT_ARRAY_ELEMENT_get();
  public static readonly int VAR_CONSTANT_ARRAY_EXPRESSION_MAX = operations_research_constraint_solverPINVOKE.ModelCache_VAR_CONSTANT_ARRAY_EXPRESSION_MAX_get();
 
  // VarArrayConstantArrayExpressionType 
  public static readonly int VAR_ARRAY_CONSTANT_ARRAY_SCAL_PROD = operations_research_constraint_solverPINVOKE.ModelCache_VAR_ARRAY_CONSTANT_ARRAY_SCAL_PROD_get();
  public static readonly int VAR_ARRAY_CONSTANT_ARRAY_EXPRESSION_MAX = operations_research_constraint_solverPINVOKE.ModelCache_VAR_ARRAY_CONSTANT_ARRAY_EXPRESSION_MAX_get();
 
  // VarArrayExpressionType 
  public static readonly int VAR_ARRAY_MAX = operations_research_constraint_solverPINVOKE.ModelCache_VAR_ARRAY_MAX_get();
  public static readonly int VAR_ARRAY_MIN = operations_research_constraint_solverPINVOKE.ModelCache_VAR_ARRAY_MIN_get();
  public static readonly int VAR_ARRAY_SUM = operations_research_constraint_solverPINVOKE.ModelCache_VAR_ARRAY_SUM_get();
  public static readonly int VAR_ARRAY_EXPRESSION_MAX = operations_research_constraint_solverPINVOKE.ModelCache_VAR_ARRAY_EXPRESSION_MAX_get();
 
  // VarArrayConstantExpressionType 
  public static readonly int VAR_ARRAY_CONSTANT_INDEX = operations_research_constraint_solverPINVOKE.ModelCache_VAR_ARRAY_CONSTANT_INDEX_get();
  public static readonly int VAR_ARRAY_CONSTANT_EXPRESSION_MAX = operations_research_constraint_solverPINVOKE.ModelCache_VAR_ARRAY_CONSTANT_EXPRESSION_MAX_get();
 
}
 
}