Assignment.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 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;
  }
 
  internal static global::System.Runtime.InteropServices.HandleRef swigRelease(Assignment 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);
    }
  }
 
  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 solver) : this(operations_research_constraint_solverPINVOKE.new_Assignment__SWIG_0(Solver.getCPtr(solver)), 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 AddObjectives(IntVarVector vars) {
    operations_research_constraint_solverPINVOKE.Assignment_AddObjectives(swigCPtr, IntVarVector.getCPtr(vars));
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public void ClearObjective() {
    operations_research_constraint_solverPINVOKE.Assignment_ClearObjective(swigCPtr);
  }
 
  public int NumObjectives() {
    int ret = operations_research_constraint_solverPINVOKE.Assignment_NumObjectives(swigCPtr);
    return ret;
  }
 
  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 IntVar ObjectiveFromIndex(int index) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Assignment_ObjectiveFromIndex(swigCPtr, index);
    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 bool HasObjectiveFromIndex(int index) {
    bool ret = operations_research_constraint_solverPINVOKE.Assignment_HasObjectiveFromIndex(swigCPtr, index);
    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 long ObjectiveMinFromIndex(int index) {
    long ret = operations_research_constraint_solverPINVOKE.Assignment_ObjectiveMinFromIndex(swigCPtr, index);
    return ret;
  }
 
  public long ObjectiveMaxFromIndex(int index) {
    long ret = operations_research_constraint_solverPINVOKE.Assignment_ObjectiveMaxFromIndex(swigCPtr, index);
    return ret;
  }
 
  public long ObjectiveValueFromIndex(int index) {
    long ret = operations_research_constraint_solverPINVOKE.Assignment_ObjectiveValueFromIndex(swigCPtr, index);
    return ret;
  }
 
  public bool ObjectiveBoundFromIndex(int index) {
    bool ret = operations_research_constraint_solverPINVOKE.Assignment_ObjectiveBoundFromIndex(swigCPtr, index);
    return ret;
  }
 
  public void SetObjectiveMinFromIndex(int index, long m) {
    operations_research_constraint_solverPINVOKE.Assignment_SetObjectiveMinFromIndex(swigCPtr, index, m);
  }
 
  public void SetObjectiveMaxFromIndex(int index, long m) {
    operations_research_constraint_solverPINVOKE.Assignment_SetObjectiveMaxFromIndex(swigCPtr, index, m);
  }
 
  public void SetObjectiveValueFromIndex(int index, long value) {
    operations_research_constraint_solverPINVOKE.Assignment_SetObjectiveValueFromIndex(swigCPtr, index, value);
  }
 
  public void SetObjectiveRangeFromIndex(int index, long l, long u) {
    operations_research_constraint_solverPINVOKE.Assignment_SetObjectiveRangeFromIndex(swigCPtr, index, 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));
  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  int[]  BackwardSequence(SequenceVar var) {
  global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Assignment_BackwardSequence(swigCPtr, SequenceVar.getCPtr(var));
  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  int[]  Unperformed(SequenceVar var) {
  global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.Assignment_Unperformed(swigCPtr, SequenceVar.getCPtr(var));
  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 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 void ActivateObjectiveFromIndex(int index) {
    operations_research_constraint_solverPINVOKE.Assignment_ActivateObjectiveFromIndex(swigCPtr, index);
  }
 
  public void DeactivateObjectiveFromIndex(int index) {
    operations_research_constraint_solverPINVOKE.Assignment_DeactivateObjectiveFromIndex(swigCPtr, index);
  }
 
  public bool ActivatedObjectiveFromIndex(int index) {
    bool ret = operations_research_constraint_solverPINVOKE.Assignment_ActivatedObjectiveFromIndex(swigCPtr, index);
    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;
  }
 
}
 
}