Assignment.cs

Go to the documentation of this file.

//------------------------------------------------------------------------------
// <auto-generated />
//
// This file was automatically generated by SWIG (http://www.swig.org).
// Version 4.0.0
//
// 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 Assignment : PropagationBaseObject {
  private global::System.Runtime.InteropServices.HandleRef swigCPtr;

  internal Assignment(global::System.IntPtr cPtr, bool cMemoryOwn) : base(operations_research_constraint_solverPINVOKE.Assignment_SWIGUpcast(cPtr), cMemoryOwn) {
    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
  }

  internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Assignment obj) {
    return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  }

  protected override void Dispose(bool disposing) {
    lock(this) {
      if (swigCPtr.Handle != global::System.IntPtr.Zero) {
        if (swigCMemOwn) {
          swigCMemOwn = false;
          operations_research_constraint_solverPINVOKE.delete_Assignment(swigCPtr);
        }
        swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
      }
      base.Dispose(disposing);
    }
  }

  public Assignment(Solver s) : this(operations_research_constraint_solverPINVOKE.new_Assignment__SWIG_0(Solver.getCPtr(s)), true) {
  }

  public Assignment(Assignment copy) : this(operations_research_constraint_solverPINVOKE.new_Assignment__SWIG_1(Assignment.getCPtr(copy)), true) {
  }

  public void Clear() {
    operations_research_constraint_solverPINVOKE.Assignment_Clear(swigCPtr);
  }

  public bool Empty() {
    bool ret = operations_research_constraint_solverPINVOKE.Assignment_Empty(swigCPtr);
    return ret;
  }

  public int Size() {
    int ret = operations_research_constraint_solverPINVOKE.Assignment_Size(swigCPtr);
    return ret;
  }

  public int NumIntVars() {
    int ret = operations_research_constraint_solverPINVOKE.Assignment_NumIntVars(swigCPtr);
    return ret;
  }

  public int NumIntervalVars() {
    int ret = operations_research_constraint_solverPINVOKE.Assignment_NumIntervalVars(swigCPtr);
    return ret;
  }

  public int NumSequenceVars() {
    int ret = operations_research_constraint_solverPINVOKE.Assignment_NumSequenceVars(swigCPtr);
    return ret;
  }

  public void Store() {
    operations_research_constraint_solverPINVOKE.Assignment_Store(swigCPtr);
  }

  public void Restore() {
    operations_research_constraint_solverPINVOKE.Assignment_Restore(swigCPtr);
  }

  public void AddObjective(IntVar v) {
    operations_research_constraint_solverPINVOKE.Assignment_AddObjective(swigCPtr, IntVar.getCPtr(v));
  }

  public void ClearObjective() {
    operations_research_constraint_solverPINVOKE.Assignment_ClearObjective(swigCPtr);
  }

  public IntVar Objective() {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Assignment_Objective(swigCPtr);
    IntVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntVar(cPtr, false);
    return ret;
  }

  public bool HasObjective() {
    bool ret = operations_research_constraint_solverPINVOKE.Assignment_HasObjective(swigCPtr);
    return ret;
  }

  public long ObjectiveMin() {
    long ret = operations_research_constraint_solverPINVOKE.Assignment_ObjectiveMin(swigCPtr);
    return ret;
  }

  public long ObjectiveMax() {
    long ret = operations_research_constraint_solverPINVOKE.Assignment_ObjectiveMax(swigCPtr);
    return ret;
  }

  public long ObjectiveValue() {
    long ret = operations_research_constraint_solverPINVOKE.Assignment_ObjectiveValue(swigCPtr);
    return ret;
  }

  public bool ObjectiveBound() {
    bool ret = operations_research_constraint_solverPINVOKE.Assignment_ObjectiveBound(swigCPtr);
    return ret;
  }

  public void SetObjectiveMin(long m) {
    operations_research_constraint_solverPINVOKE.Assignment_SetObjectiveMin(swigCPtr, m);
  }

  public void SetObjectiveMax(long m) {
    operations_research_constraint_solverPINVOKE.Assignment_SetObjectiveMax(swigCPtr, m);
  }

  public void SetObjectiveValue(long value) {
    operations_research_constraint_solverPINVOKE.Assignment_SetObjectiveValue(swigCPtr, value);
  }

  public void SetObjectiveRange(long l, long u) {
    operations_research_constraint_solverPINVOKE.Assignment_SetObjectiveRange(swigCPtr, l, u);
  }

  public IntVarElement Add(IntVar var) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Assignment_Add__SWIG_0(swigCPtr, IntVar.getCPtr(var));
    IntVarElement ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntVarElement(cPtr, false);
    return ret;
  }

  public void Add(IntVarVector vars) {
    operations_research_constraint_solverPINVOKE.Assignment_Add__SWIG_1(swigCPtr, IntVarVector.getCPtr(vars));
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
  }

  public IntVarElement FastAdd(IntVar var) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Assignment_FastAdd__SWIG_0(swigCPtr, IntVar.getCPtr(var));
    IntVarElement ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntVarElement(cPtr, false);
    return ret;
  }

  public long Min(IntVar var) {
    long ret = operations_research_constraint_solverPINVOKE.Assignment_Min(swigCPtr, IntVar.getCPtr(var));
    return ret;
  }

  public long Max(IntVar var) {
    long ret = operations_research_constraint_solverPINVOKE.Assignment_Max(swigCPtr, IntVar.getCPtr(var));
    return ret;
  }

  public long Value(IntVar var) {
    long ret = operations_research_constraint_solverPINVOKE.Assignment_Value(swigCPtr, IntVar.getCPtr(var));
    return ret;
  }

  public bool Bound(IntVar var) {
    bool ret = operations_research_constraint_solverPINVOKE.Assignment_Bound(swigCPtr, IntVar.getCPtr(var));
    return ret;
  }

  public void SetMin(IntVar var, long m) {
    operations_research_constraint_solverPINVOKE.Assignment_SetMin(swigCPtr, IntVar.getCPtr(var), m);
  }

  public void SetMax(IntVar var, long m) {
    operations_research_constraint_solverPINVOKE.Assignment_SetMax(swigCPtr, IntVar.getCPtr(var), m);
  }

  public void SetRange(IntVar var, long l, long u) {
    operations_research_constraint_solverPINVOKE.Assignment_SetRange(swigCPtr, IntVar.getCPtr(var), l, u);
  }

  public void SetValue(IntVar var, long value) {
    operations_research_constraint_solverPINVOKE.Assignment_SetValue(swigCPtr, IntVar.getCPtr(var), value);
  }

  public IntervalVarElement Add(IntervalVar var) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Assignment_Add__SWIG_2(swigCPtr, IntervalVar.getCPtr(var));
    IntervalVarElement ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntervalVarElement(cPtr, false);
    return ret;
  }

  public void Add(IntervalVarVector vars) {
    operations_research_constraint_solverPINVOKE.Assignment_Add__SWIG_3(swigCPtr, IntervalVarVector.getCPtr(vars));
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
  }

  public IntervalVarElement FastAdd(IntervalVar var) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Assignment_FastAdd__SWIG_1(swigCPtr, IntervalVar.getCPtr(var));
    IntervalVarElement ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntervalVarElement(cPtr, false);
    return ret;
  }

  public long StartMin(IntervalVar var) {
    long ret = operations_research_constraint_solverPINVOKE.Assignment_StartMin(swigCPtr, IntervalVar.getCPtr(var));
    return ret;
  }

  public long StartMax(IntervalVar var) {
    long ret = operations_research_constraint_solverPINVOKE.Assignment_StartMax(swigCPtr, IntervalVar.getCPtr(var));
    return ret;
  }

  public long StartValue(IntervalVar var) {
    long ret = operations_research_constraint_solverPINVOKE.Assignment_StartValue(swigCPtr, IntervalVar.getCPtr(var));
    return ret;
  }

  public long DurationMin(IntervalVar var) {
    long ret = operations_research_constraint_solverPINVOKE.Assignment_DurationMin(swigCPtr, IntervalVar.getCPtr(var));
    return ret;
  }

  public long DurationMax(IntervalVar var) {
    long ret = operations_research_constraint_solverPINVOKE.Assignment_DurationMax(swigCPtr, IntervalVar.getCPtr(var));
    return ret;
  }

  public long DurationValue(IntervalVar var) {
    long ret = operations_research_constraint_solverPINVOKE.Assignment_DurationValue(swigCPtr, IntervalVar.getCPtr(var));
    return ret;
  }

  public long EndMin(IntervalVar var) {
    long ret = operations_research_constraint_solverPINVOKE.Assignment_EndMin(swigCPtr, IntervalVar.getCPtr(var));
    return ret;
  }

  public long EndMax(IntervalVar var) {
    long ret = operations_research_constraint_solverPINVOKE.Assignment_EndMax(swigCPtr, IntervalVar.getCPtr(var));
    return ret;
  }

  public long EndValue(IntervalVar var) {
    long ret = operations_research_constraint_solverPINVOKE.Assignment_EndValue(swigCPtr, IntervalVar.getCPtr(var));
    return ret;
  }

  public long PerformedMin(IntervalVar var) {
    long ret = operations_research_constraint_solverPINVOKE.Assignment_PerformedMin(swigCPtr, IntervalVar.getCPtr(var));
    return ret;
  }

  public long PerformedMax(IntervalVar var) {
    long ret = operations_research_constraint_solverPINVOKE.Assignment_PerformedMax(swigCPtr, IntervalVar.getCPtr(var));
    return ret;
  }

  public long PerformedValue(IntervalVar var) {
    long ret = operations_research_constraint_solverPINVOKE.Assignment_PerformedValue(swigCPtr, IntervalVar.getCPtr(var));
    return ret;
  }

  public void SetStartMin(IntervalVar var, long m) {
    operations_research_constraint_solverPINVOKE.Assignment_SetStartMin(swigCPtr, IntervalVar.getCPtr(var), m);
  }

  public void SetStartMax(IntervalVar var, long m) {
    operations_research_constraint_solverPINVOKE.Assignment_SetStartMax(swigCPtr, IntervalVar.getCPtr(var), m);
  }

  public void SetStartRange(IntervalVar var, long mi, long ma) {
    operations_research_constraint_solverPINVOKE.Assignment_SetStartRange(swigCPtr, IntervalVar.getCPtr(var), mi, ma);
  }

  public void SetStartValue(IntervalVar var, long value) {
    operations_research_constraint_solverPINVOKE.Assignment_SetStartValue(swigCPtr, IntervalVar.getCPtr(var), value);
  }

  public void SetDurationMin(IntervalVar var, long m) {
    operations_research_constraint_solverPINVOKE.Assignment_SetDurationMin(swigCPtr, IntervalVar.getCPtr(var), m);
  }

  public void SetDurationMax(IntervalVar var, long m) {
    operations_research_constraint_solverPINVOKE.Assignment_SetDurationMax(swigCPtr, IntervalVar.getCPtr(var), m);
  }

  public void SetDurationRange(IntervalVar var, long mi, long ma) {
    operations_research_constraint_solverPINVOKE.Assignment_SetDurationRange(swigCPtr, IntervalVar.getCPtr(var), mi, ma);
  }

  public void SetDurationValue(IntervalVar var, long value) {
    operations_research_constraint_solverPINVOKE.Assignment_SetDurationValue(swigCPtr, IntervalVar.getCPtr(var), value);
  }

  public void SetEndMin(IntervalVar var, long m) {
    operations_research_constraint_solverPINVOKE.Assignment_SetEndMin(swigCPtr, IntervalVar.getCPtr(var), m);
  }

  public void SetEndMax(IntervalVar var, long m) {
    operations_research_constraint_solverPINVOKE.Assignment_SetEndMax(swigCPtr, IntervalVar.getCPtr(var), m);
  }

  public void SetEndRange(IntervalVar var, long mi, long ma) {
    operations_research_constraint_solverPINVOKE.Assignment_SetEndRange(swigCPtr, IntervalVar.getCPtr(var), mi, ma);
  }

  public void SetEndValue(IntervalVar var, long value) {
    operations_research_constraint_solverPINVOKE.Assignment_SetEndValue(swigCPtr, IntervalVar.getCPtr(var), value);
  }

  public void SetPerformedMin(IntervalVar var, long m) {
    operations_research_constraint_solverPINVOKE.Assignment_SetPerformedMin(swigCPtr, IntervalVar.getCPtr(var), m);
  }

  public void SetPerformedMax(IntervalVar var, long m) {
    operations_research_constraint_solverPINVOKE.Assignment_SetPerformedMax(swigCPtr, IntervalVar.getCPtr(var), m);
  }

  public void SetPerformedRange(IntervalVar var, long mi, long ma) {
    operations_research_constraint_solverPINVOKE.Assignment_SetPerformedRange(swigCPtr, IntervalVar.getCPtr(var), mi, ma);
  }

  public void SetPerformedValue(IntervalVar var, long value) {
    operations_research_constraint_solverPINVOKE.Assignment_SetPerformedValue(swigCPtr, IntervalVar.getCPtr(var), value);
  }

  public SequenceVarElement Add(SequenceVar var) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Assignment_Add__SWIG_4(swigCPtr, SequenceVar.getCPtr(var));
    SequenceVarElement ret = (cPtr == global::System.IntPtr.Zero) ? null : new SequenceVarElement(cPtr, false);
    return ret;
  }

  public void Add(SequenceVarVector vars) {
    operations_research_constraint_solverPINVOKE.Assignment_Add__SWIG_5(swigCPtr, SequenceVarVector.getCPtr(vars));
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
  }

  public SequenceVarElement FastAdd(SequenceVar var) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Assignment_FastAdd__SWIG_2(swigCPtr, SequenceVar.getCPtr(var));
    SequenceVarElement ret = (cPtr == global::System.IntPtr.Zero) ? null : new SequenceVarElement(cPtr, false);
    return ret;
  }

  public  int[]  ForwardSequence(SequenceVar var) {
  global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Assignment_ForwardSequence(swigCPtr, SequenceVar.getCPtr(var));
  CpIntVector tmpVector = null;
  if (cPtr != global::System.IntPtr.Zero) {
    tmpVector = new CpIntVector(cPtr, true);
    int[] outArray = new int[tmpVector.Count];
    tmpVector.CopyTo(outArray);
    return outArray;
  }
  return null;
}

  public  int[]  BackwardSequence(SequenceVar var) {
  global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Assignment_BackwardSequence(swigCPtr, SequenceVar.getCPtr(var));
  CpIntVector tmpVector = null;
  if (cPtr != global::System.IntPtr.Zero) {
    tmpVector = new CpIntVector(cPtr, true);
    int[] outArray = new int[tmpVector.Count];
    tmpVector.CopyTo(outArray);
    return outArray;
  }
  return null;
}

  public  int[]  Unperformed(SequenceVar var) {
  global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Assignment_Unperformed(swigCPtr, SequenceVar.getCPtr(var));
  CpIntVector tmpVector = null;
  if (cPtr != global::System.IntPtr.Zero) {
    tmpVector = new CpIntVector(cPtr, true);
    int[] outArray = new int[tmpVector.Count];
    tmpVector.CopyTo(outArray);
    return outArray;
  }
  return null;
}

  public void SetSequence(SequenceVar var,  int[]  forward_sequence,  int[]  backward_sequence,  int[]  unperformed) {
    operations_research_constraint_solverPINVOKE.Assignment_SetSequence(swigCPtr, SequenceVar.getCPtr(var),  forward_sequence.Length, forward_sequence ,  backward_sequence.Length, backward_sequence ,  unperformed.Length, unperformed );
  }

  public void SetForwardSequence(SequenceVar var,  int[]  forward_sequence) {
    operations_research_constraint_solverPINVOKE.Assignment_SetForwardSequence(swigCPtr, SequenceVar.getCPtr(var),  forward_sequence.Length, forward_sequence );
  }

  public void SetBackwardSequence(SequenceVar var,  int[]  backward_sequence) {
    operations_research_constraint_solverPINVOKE.Assignment_SetBackwardSequence(swigCPtr, SequenceVar.getCPtr(var),  backward_sequence.Length, backward_sequence );
  }

  public void SetUnperformed(SequenceVar var,  int[]  unperformed) {
    operations_research_constraint_solverPINVOKE.Assignment_SetUnperformed(swigCPtr, SequenceVar.getCPtr(var),  unperformed.Length, unperformed );
  }

  public void Activate(IntVar var) {
    operations_research_constraint_solverPINVOKE.Assignment_Activate__SWIG_0(swigCPtr, IntVar.getCPtr(var));
  }

  public void Deactivate(IntVar var) {
    operations_research_constraint_solverPINVOKE.Assignment_Deactivate__SWIG_0(swigCPtr, IntVar.getCPtr(var));
  }

  public bool Activated(IntVar var) {
    bool ret = operations_research_constraint_solverPINVOKE.Assignment_Activated__SWIG_0(swigCPtr, IntVar.getCPtr(var));
    return ret;
  }

  public void Activate(IntervalVar var) {
    operations_research_constraint_solverPINVOKE.Assignment_Activate__SWIG_1(swigCPtr, IntervalVar.getCPtr(var));
  }

  public void Deactivate(IntervalVar var) {
    operations_research_constraint_solverPINVOKE.Assignment_Deactivate__SWIG_1(swigCPtr, IntervalVar.getCPtr(var));
  }

  public bool Activated(IntervalVar var) {
    bool ret = operations_research_constraint_solverPINVOKE.Assignment_Activated__SWIG_1(swigCPtr, IntervalVar.getCPtr(var));
    return ret;
  }

  public void Activate(SequenceVar var) {
    operations_research_constraint_solverPINVOKE.Assignment_Activate__SWIG_2(swigCPtr, SequenceVar.getCPtr(var));
  }

  public void Deactivate(SequenceVar var) {
    operations_research_constraint_solverPINVOKE.Assignment_Deactivate__SWIG_2(swigCPtr, SequenceVar.getCPtr(var));
  }

  public bool Activated(SequenceVar var) {
    bool ret = operations_research_constraint_solverPINVOKE.Assignment_Activated__SWIG_2(swigCPtr, SequenceVar.getCPtr(var));
    return ret;
  }

  public void ActivateObjective() {
    operations_research_constraint_solverPINVOKE.Assignment_ActivateObjective(swigCPtr);
  }

  public void DeactivateObjective() {
    operations_research_constraint_solverPINVOKE.Assignment_DeactivateObjective(swigCPtr);
  }

  public bool ActivatedObjective() {
    bool ret = operations_research_constraint_solverPINVOKE.Assignment_ActivatedObjective(swigCPtr);
    return ret;
  }

  public override string ToString() {
    string ret = operations_research_constraint_solverPINVOKE.Assignment_ToString(swigCPtr);
    return ret;
  }

  public bool AreAllElementsBound() {
    bool ret = operations_research_constraint_solverPINVOKE.Assignment_AreAllElementsBound(swigCPtr);
    return ret;
  }

  public bool Contains(IntVar var) {
    bool ret = operations_research_constraint_solverPINVOKE.Assignment_Contains__SWIG_0(swigCPtr, IntVar.getCPtr(var));
    return ret;
  }

  public bool Contains(IntervalVar var) {
    bool ret = operations_research_constraint_solverPINVOKE.Assignment_Contains__SWIG_1(swigCPtr, IntervalVar.getCPtr(var));
    return ret;
  }

  public bool Contains(SequenceVar var) {
    bool ret = operations_research_constraint_solverPINVOKE.Assignment_Contains__SWIG_2(swigCPtr, SequenceVar.getCPtr(var));
    return ret;
  }

  public void CopyIntersection(Assignment assignment) {
    operations_research_constraint_solverPINVOKE.Assignment_CopyIntersection(swigCPtr, Assignment.getCPtr(assignment));
  }

  public void Copy(Assignment assignment) {
    operations_research_constraint_solverPINVOKE.Assignment_Copy(swigCPtr, Assignment.getCPtr(assignment));
  }

  public AssignmentIntContainer IntVarContainer() {
    AssignmentIntContainer ret = new AssignmentIntContainer(operations_research_constraint_solverPINVOKE.Assignment_IntVarContainer(swigCPtr), false);
    return ret;
  }

  public AssignmentIntContainer MutableIntVarContainer() {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Assignment_MutableIntVarContainer(swigCPtr);
    AssignmentIntContainer ret = (cPtr == global::System.IntPtr.Zero) ? null : new AssignmentIntContainer(cPtr, false);
    return ret;
  }

  public AssignmentIntervalContainer IntervalVarContainer() {
    AssignmentIntervalContainer ret = new AssignmentIntervalContainer(operations_research_constraint_solverPINVOKE.Assignment_IntervalVarContainer(swigCPtr), false);
    return ret;
  }

  public AssignmentIntervalContainer MutableIntervalVarContainer() {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Assignment_MutableIntervalVarContainer(swigCPtr);
    AssignmentIntervalContainer ret = (cPtr == global::System.IntPtr.Zero) ? null : new AssignmentIntervalContainer(cPtr, false);
    return ret;
  }

  public AssignmentSequenceContainer SequenceVarContainer() {
    AssignmentSequenceContainer ret = new AssignmentSequenceContainer(operations_research_constraint_solverPINVOKE.Assignment_SequenceVarContainer(swigCPtr), false);
    return ret;
  }

  public AssignmentSequenceContainer MutableSequenceVarContainer() {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Assignment_MutableSequenceVarContainer(swigCPtr);
    AssignmentSequenceContainer ret = (cPtr == global::System.IntPtr.Zero) ? null : new AssignmentSequenceContainer(cPtr, false);
    return ret;
  }

}

}