RoutingModel.cs

Go to the documentation of this file.

//------------------------------------------------------------------------------
// <auto-generated />
//
// This file was automatically generated by SWIG (http://www.swig.org).
// Version 4.0.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.Collections.Generic;

public partial class RoutingModel : global::System.IDisposable {
  private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  protected bool swigCMemOwn;

  internal RoutingModel(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(RoutingModel obj) {
    return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  }

  ~RoutingModel() {
    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_RoutingModel(swigCPtr);
        }
        swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
      }
    }
  }

  // Keep reference to delegate to avoid GC to collect them early.
  private List<LongToLong> unaryTransitCallbacks;
  private LongToLong StoreLongToLong(LongToLong c) {
    if (unaryTransitCallbacks == null)
      unaryTransitCallbacks = new List<LongToLong>();
    unaryTransitCallbacks.Add(c);
    return c;
  }

  private List<LongLongToLong> transitCallbacks;
  private LongLongToLong StoreLongLongToLong(LongLongToLong c) {
    if (transitCallbacks == null)
      transitCallbacks = new List<LongLongToLong>();
    transitCallbacks.Add(c);
    return c;
  }

  private List<VoidToVoid> solutionCallbacks;
  private VoidToVoid StoreVoidToVoid(VoidToVoid c) {
    if (solutionCallbacks == null)
      solutionCallbacks = new List<VoidToVoid>();
    solutionCallbacks.Add(c);
    return c;
  }

  public partial class VehicleTypeContainer : global::System.IDisposable {
    private global::System.Runtime.InteropServices.HandleRef swigCPtr;
    protected bool swigCMemOwn;
  
    internal VehicleTypeContainer(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(VehicleTypeContainer obj) {
      return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
    }
  
    ~VehicleTypeContainer() {
      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_RoutingModel_VehicleTypeContainer(swigCPtr);
          }
          swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
        }
      }
    }
  
      public partial class VehicleClassEntry : global::System.IDisposable {
        private global::System.Runtime.InteropServices.HandleRef swigCPtr;
        protected bool swigCMemOwn;
      
        internal VehicleClassEntry(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(VehicleClassEntry obj) {
          return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
        }
      
        ~VehicleClassEntry() {
          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_RoutingModel_VehicleTypeContainer_VehicleClassEntry(swigCPtr);
              }
              swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
            }
          }
        }
      
        public int vehicle_class {
          set {
            operations_research_constraint_solverPINVOKE.RoutingModel_VehicleTypeContainer_VehicleClassEntry_vehicle_class_set(swigCPtr, value);
          } 
          get {
            int ret = operations_research_constraint_solverPINVOKE.RoutingModel_VehicleTypeContainer_VehicleClassEntry_vehicle_class_get(swigCPtr);
            return ret;
          } 
        }
      
        public long fixed_cost {
          set {
            operations_research_constraint_solverPINVOKE.RoutingModel_VehicleTypeContainer_VehicleClassEntry_fixed_cost_set(swigCPtr, value);
          } 
          get {
            long ret = operations_research_constraint_solverPINVOKE.RoutingModel_VehicleTypeContainer_VehicleClassEntry_fixed_cost_get(swigCPtr);
            return ret;
          } 
        }
      
        public VehicleClassEntry() : this(operations_research_constraint_solverPINVOKE.new_RoutingModel_VehicleTypeContainer_VehicleClassEntry(), true) {
        }
      
      }
  
    public int NumTypes() {
      int ret = operations_research_constraint_solverPINVOKE.RoutingModel_VehicleTypeContainer_NumTypes(swigCPtr);
      return ret;
    }
  
    public int Type(int vehicle) {
      int ret = operations_research_constraint_solverPINVOKE.RoutingModel_VehicleTypeContainer_Type(swigCPtr, vehicle);
      return ret;
    }
  
    public IntVector type_index_of_vehicle {
      set {
        operations_research_constraint_solverPINVOKE.RoutingModel_VehicleTypeContainer_type_index_of_vehicle_set(swigCPtr, IntVector.getCPtr(value));
      } 
      get {
        global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_VehicleTypeContainer_type_index_of_vehicle_get(swigCPtr);
        IntVector ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntVector(cPtr, false);
        return ret;
      } 
    }
  
    public SWIGTYPE_p_std__vectorT_std__setT_operations_research__RoutingModel__VehicleTypeContainer__VehicleClassEntry_t_t sorted_vehicle_classes_per_type {
      set {
        operations_research_constraint_solverPINVOKE.RoutingModel_VehicleTypeContainer_sorted_vehicle_classes_per_type_set(swigCPtr, SWIGTYPE_p_std__vectorT_std__setT_operations_research__RoutingModel__VehicleTypeContainer__VehicleClassEntry_t_t.getCPtr(value));
      } 
      get {
        global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_VehicleTypeContainer_sorted_vehicle_classes_per_type_get(swigCPtr);
        SWIGTYPE_p_std__vectorT_std__setT_operations_research__RoutingModel__VehicleTypeContainer__VehicleClassEntry_t_t ret = (cPtr == global::System.IntPtr.Zero) ? null : new SWIGTYPE_p_std__vectorT_std__setT_operations_research__RoutingModel__VehicleTypeContainer__VehicleClassEntry_t_t(cPtr, false);
        return ret;
      } 
    }
  
    public SWIGTYPE_p_std__vectorT_std__dequeT_int_t_t vehicles_per_vehicle_class {
      set {
        operations_research_constraint_solverPINVOKE.RoutingModel_VehicleTypeContainer_vehicles_per_vehicle_class_set(swigCPtr, SWIGTYPE_p_std__vectorT_std__dequeT_int_t_t.getCPtr(value));
      } 
      get {
        global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_VehicleTypeContainer_vehicles_per_vehicle_class_get(swigCPtr);
        SWIGTYPE_p_std__vectorT_std__dequeT_int_t_t ret = (cPtr == global::System.IntPtr.Zero) ? null : new SWIGTYPE_p_std__vectorT_std__dequeT_int_t_t(cPtr, false);
        return ret;
      } 
    }
  
    public VehicleTypeContainer() : this(operations_research_constraint_solverPINVOKE.new_RoutingModel_VehicleTypeContainer(), true) {
    }
  
  }

  public partial class ResourceGroup : global::System.IDisposable {
    private global::System.Runtime.InteropServices.HandleRef swigCPtr;
    protected bool swigCMemOwn;
  
    internal ResourceGroup(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(ResourceGroup obj) {
      return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
    }
  
    ~ResourceGroup() {
      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_RoutingModel_ResourceGroup(swigCPtr);
          }
          swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
        }
      }
    }
  
      public partial class Attributes : global::System.IDisposable {
        private global::System.Runtime.InteropServices.HandleRef swigCPtr;
        protected bool swigCMemOwn;
      
        internal Attributes(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(Attributes obj) {
          return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
        }
      
        ~Attributes() {
          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_RoutingModel_ResourceGroup_Attributes(swigCPtr);
              }
              swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
            }
          }
        }
      
        public Attributes() : this(operations_research_constraint_solverPINVOKE.new_RoutingModel_ResourceGroup_Attributes__SWIG_0(), true) {
        }
      
        public Attributes(Domain start_domain, Domain end_domain) : this(operations_research_constraint_solverPINVOKE.new_RoutingModel_ResourceGroup_Attributes__SWIG_1(Domain.getCPtr(start_domain), Domain.getCPtr(end_domain)), true) {
          if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
        }
      
        public Domain StartDomain() {
          Domain ret = new Domain(operations_research_constraint_solverPINVOKE.RoutingModel_ResourceGroup_Attributes_StartDomain(swigCPtr), false);
          return ret;
        }
      
        public Domain EndDomain() {
          Domain ret = new Domain(operations_research_constraint_solverPINVOKE.RoutingModel_ResourceGroup_Attributes_EndDomain(swigCPtr), false);
          return ret;
        }
      
      }
  
      public partial class Resource : global::System.IDisposable {
        private global::System.Runtime.InteropServices.HandleRef swigCPtr;
        protected bool swigCMemOwn;
      
        internal Resource(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(Resource obj) {
          return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
        }
      
        ~Resource() {
          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_RoutingModel_ResourceGroup_Resource(swigCPtr);
              }
              swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
            }
          }
        }
      
        public RoutingModel.ResourceGroup.Attributes GetDimensionAttributes(RoutingDimension dimension) {
          RoutingModel.ResourceGroup.Attributes ret = new RoutingModel.ResourceGroup.Attributes(operations_research_constraint_solverPINVOKE.RoutingModel_ResourceGroup_Resource_GetDimensionAttributes(swigCPtr, RoutingDimension.getCPtr(dimension)), false);
          return ret;
        }
      
      }
  
    public ResourceGroup(RoutingModel model) : this(operations_research_constraint_solverPINVOKE.new_RoutingModel_ResourceGroup(RoutingModel.getCPtr(model)), true) {
    }
  
    public int AddResource(RoutingModel.ResourceGroup.Attributes attributes, RoutingDimension dimension) {
      int ret = operations_research_constraint_solverPINVOKE.RoutingModel_ResourceGroup_AddResource(swigCPtr, RoutingModel.ResourceGroup.Attributes.getCPtr(attributes), RoutingDimension.getCPtr(dimension));
      if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    }
  
    public void NotifyVehicleRequiresAResource(int vehicle) {
      operations_research_constraint_solverPINVOKE.RoutingModel_ResourceGroup_NotifyVehicleRequiresAResource(swigCPtr, vehicle);
    }
  
    public  int[]  GetVehiclesRequiringAResource() {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_ResourceGroup_GetVehiclesRequiringAResource(swigCPtr);
    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 bool VehicleRequiresAResource(int vehicle) {
      bool ret = operations_research_constraint_solverPINVOKE.RoutingModel_ResourceGroup_VehicleRequiresAResource(swigCPtr, vehicle);
      return ret;
    }
  
    public SWIGTYPE_p_std__vectorT_operations_research__RoutingModel__ResourceGroup__Resource_t GetResources() {
      SWIGTYPE_p_std__vectorT_operations_research__RoutingModel__ResourceGroup__Resource_t ret = new SWIGTYPE_p_std__vectorT_operations_research__RoutingModel__ResourceGroup__Resource_t(operations_research_constraint_solverPINVOKE.RoutingModel_ResourceGroup_GetResources(swigCPtr), false);
      return ret;
    }
  
    public RoutingModel.ResourceGroup.Resource GetResource(int resource_index) {
      RoutingModel.ResourceGroup.Resource ret = new RoutingModel.ResourceGroup.Resource(operations_research_constraint_solverPINVOKE.RoutingModel_ResourceGroup_GetResource(swigCPtr, resource_index), false);
      return ret;
    }
  
    public SWIGTYPE_p_absl__flat_hash_setT_operations_research__RoutingModel__DimensionIndex_t GetAffectedDimensionIndices() {
      SWIGTYPE_p_absl__flat_hash_setT_operations_research__RoutingModel__DimensionIndex_t ret = new SWIGTYPE_p_absl__flat_hash_setT_operations_research__RoutingModel__DimensionIndex_t(operations_research_constraint_solverPINVOKE.RoutingModel_ResourceGroup_GetAffectedDimensionIndices(swigCPtr), false);
      return ret;
    }
  
    public int Size() {
      int ret = operations_research_constraint_solverPINVOKE.RoutingModel_ResourceGroup_Size(swigCPtr);
      return ret;
    }
  
  }

  public static long kNoPenalty {
    get {
      long ret = operations_research_constraint_solverPINVOKE.RoutingModel_kNoPenalty_get();
      return ret;
    } 
  }

  public static int kNoDisjunction {
  get {
        return operations_research_constraint_solverPINVOKE.RoutingModel_kNoDisjunction_get();
  }

  }

  public static int kNoDimension {
  get {
        return operations_research_constraint_solverPINVOKE.RoutingModel_kNoDimension_get();
  }

  }

  public RoutingModel(RoutingIndexManager index_manager) : this(operations_research_constraint_solverPINVOKE.new_RoutingModel__SWIG_0(RoutingIndexManager.getCPtr(index_manager)), true) {
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
  }

  public RoutingModel(RoutingIndexManager index_manager, Google.OrTools.ConstraintSolver.RoutingModelParameters parameters) : this(operations_research_constraint_solverPINVOKE.new_RoutingModel__SWIG_1(RoutingIndexManager.getCPtr(index_manager), parameters.CalculateSize(), ProtoHelper.ProtoToByteArray(parameters)), true) {
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
  }

  public int RegisterUnaryTransitVector( long[]  values) {
    int ret = operations_research_constraint_solverPINVOKE.RoutingModel_RegisterUnaryTransitVector(swigCPtr,  values.Length, values );
    return ret;
  }

  public int RegisterUnaryTransitCallback( LongToLong  callback) {
    int ret = operations_research_constraint_solverPINVOKE.RoutingModel_RegisterUnaryTransitCallback(swigCPtr,  StoreLongToLong(callback) );
    return ret;
  }

  public int RegisterPositiveUnaryTransitCallback( LongToLong  callback) {
    int ret = operations_research_constraint_solverPINVOKE.RoutingModel_RegisterPositiveUnaryTransitCallback(swigCPtr,  StoreLongToLong(callback) );
    return ret;
  }

  public int RegisterTransitMatrix( long[][]  values) {
    int ret = operations_research_constraint_solverPINVOKE.RoutingModel_RegisterTransitMatrix(swigCPtr, 
  values.GetLength(0),
  NestedArrayHelper.GetArraySecondSize(values),
  NestedArrayHelper.GetFlatArray(values)
);
    return ret;
  }

  public int RegisterTransitCallback( LongLongToLong  callback) {
    int ret = operations_research_constraint_solverPINVOKE.RoutingModel_RegisterTransitCallback(swigCPtr,  StoreLongLongToLong(callback) );
    return ret;
  }

  public int RegisterPositiveTransitCallback( LongLongToLong  callback) {
    int ret = operations_research_constraint_solverPINVOKE.RoutingModel_RegisterPositiveTransitCallback(swigCPtr,  StoreLongLongToLong(callback) );
    return ret;
  }

  public bool AddDimension(int evaluator_index, long slack_max, long capacity, bool fix_start_cumul_to_zero, string name) {
    bool ret = operations_research_constraint_solverPINVOKE.RoutingModel_AddDimension(swigCPtr, evaluator_index, slack_max, capacity, fix_start_cumul_to_zero, name);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public bool AddDimensionWithVehicleTransits( int[]  evaluator_indices, long slack_max, long capacity, bool fix_start_cumul_to_zero, string name) {
    bool ret = operations_research_constraint_solverPINVOKE.RoutingModel_AddDimensionWithVehicleTransits(swigCPtr,  evaluator_indices.Length, evaluator_indices , slack_max, capacity, fix_start_cumul_to_zero, name);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public bool AddDimensionWithVehicleCapacity(int evaluator_index, long slack_max,  long[]  vehicle_capacities, bool fix_start_cumul_to_zero, string name) {
    bool ret = operations_research_constraint_solverPINVOKE.RoutingModel_AddDimensionWithVehicleCapacity(swigCPtr, evaluator_index, slack_max,  vehicle_capacities.Length, vehicle_capacities , fix_start_cumul_to_zero, name);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public bool AddDimensionWithVehicleTransitAndCapacity( int[]  evaluator_indices, long slack_max,  long[]  vehicle_capacities, bool fix_start_cumul_to_zero, string name) {
    bool ret = operations_research_constraint_solverPINVOKE.RoutingModel_AddDimensionWithVehicleTransitAndCapacity(swigCPtr,  evaluator_indices.Length, evaluator_indices , slack_max,  vehicle_capacities.Length, vehicle_capacities , fix_start_cumul_to_zero, name);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public IntBoolPair AddConstantDimensionWithSlack(long value, long capacity, long slack_max, bool fix_start_cumul_to_zero, string name) {
    IntBoolPair ret = new IntBoolPair(operations_research_constraint_solverPINVOKE.RoutingModel_AddConstantDimensionWithSlack(swigCPtr, value, capacity, slack_max, fix_start_cumul_to_zero, name), true);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public IntBoolPair AddConstantDimension(long value, long capacity, bool fix_start_cumul_to_zero, string name) {
    IntBoolPair ret = new IntBoolPair(operations_research_constraint_solverPINVOKE.RoutingModel_AddConstantDimension(swigCPtr, value, capacity, fix_start_cumul_to_zero, name), true);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public IntBoolPair AddVectorDimension( long[]  values, long capacity, bool fix_start_cumul_to_zero, string name) {
    IntBoolPair ret = new IntBoolPair(operations_research_constraint_solverPINVOKE.RoutingModel_AddVectorDimension(swigCPtr,  values.Length, values , capacity, fix_start_cumul_to_zero, name), true);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public IntBoolPair AddMatrixDimension( long[][]  values, long capacity, bool fix_start_cumul_to_zero, string name) {
    IntBoolPair ret = new IntBoolPair(operations_research_constraint_solverPINVOKE.RoutingModel_AddMatrixDimension(swigCPtr, 
  values.GetLength(0),
  NestedArrayHelper.GetArraySecondSize(values),
  NestedArrayHelper.GetFlatArray(values)
, capacity, fix_start_cumul_to_zero, name), true);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public Constraint MakePathSpansAndTotalSlacks(RoutingDimension dimension, IntVarVector spans, IntVarVector total_slacks) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_MakePathSpansAndTotalSlacks(swigCPtr, RoutingDimension.getCPtr(dimension), IntVarVector.getCPtr(spans), IntVarVector.getCPtr(total_slacks));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public SWIGTYPE_p_std__vectorT_std__unique_ptrT_operations_research__GlobalDimensionCumulOptimizer_t_t GetGlobalDimensionCumulMPOptimizers() {
    SWIGTYPE_p_std__vectorT_std__unique_ptrT_operations_research__GlobalDimensionCumulOptimizer_t_t ret = new SWIGTYPE_p_std__vectorT_std__unique_ptrT_operations_research__GlobalDimensionCumulOptimizer_t_t(operations_research_constraint_solverPINVOKE.RoutingModel_GetGlobalDimensionCumulMPOptimizers(swigCPtr), false);
    return ret;
  }

  public SWIGTYPE_p_operations_research__GlobalDimensionCumulOptimizer GetMutableGlobalCumulMPOptimizer(RoutingDimension dimension) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_GetMutableGlobalCumulMPOptimizer(swigCPtr, RoutingDimension.getCPtr(dimension));
    SWIGTYPE_p_operations_research__GlobalDimensionCumulOptimizer ret = (cPtr == global::System.IntPtr.Zero) ? null : new SWIGTYPE_p_operations_research__GlobalDimensionCumulOptimizer(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public bool HasDimension(string dimension_name) {
    bool ret = operations_research_constraint_solverPINVOKE.RoutingModel_HasDimension(swigCPtr, dimension_name);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public RoutingDimension GetDimensionOrDie(string dimension_name) {
    RoutingDimension ret = new RoutingDimension(operations_research_constraint_solverPINVOKE.RoutingModel_GetDimensionOrDie(swigCPtr, dimension_name), false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public RoutingDimension GetMutableDimension(string dimension_name) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_GetMutableDimension(swigCPtr, dimension_name);
    RoutingDimension ret = (cPtr == global::System.IntPtr.Zero) ? null : new RoutingDimension(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public void SetPrimaryConstrainedDimension(string dimension_name) {
    operations_research_constraint_solverPINVOKE.RoutingModel_SetPrimaryConstrainedDimension(swigCPtr, dimension_name);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
  }

  public string GetPrimaryConstrainedDimension() {
    string ret = operations_research_constraint_solverPINVOKE.RoutingModel_GetPrimaryConstrainedDimension(swigCPtr);
    return ret;
  }

  public int AddResourceGroup() {
    int ret = operations_research_constraint_solverPINVOKE.RoutingModel_AddResourceGroup(swigCPtr);
    return ret;
  }

  public SWIGTYPE_p_std__vectorT_std__unique_ptrT_operations_research__RoutingModel__ResourceGroup_t_t GetResourceGroups() {
    SWIGTYPE_p_std__vectorT_std__unique_ptrT_operations_research__RoutingModel__ResourceGroup_t_t ret = new SWIGTYPE_p_std__vectorT_std__unique_ptrT_operations_research__RoutingModel__ResourceGroup_t_t(operations_research_constraint_solverPINVOKE.RoutingModel_GetResourceGroups(swigCPtr), false);
    return ret;
  }

  public RoutingModel.ResourceGroup GetResourceGroup(int rg_index) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_GetResourceGroup(swigCPtr, rg_index);
    RoutingModel.ResourceGroup ret = (cPtr == global::System.IntPtr.Zero) ? null : new RoutingModel.ResourceGroup(cPtr, false);
    return ret;
  }

  public  int[]  GetDimensionResourceGroupIndices(RoutingDimension dimension) {
  global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_GetDimensionResourceGroupIndices(swigCPtr, RoutingDimension.getCPtr(dimension));
  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 GetDimensionResourceGroupIndex(RoutingDimension dimension) {
    int ret = operations_research_constraint_solverPINVOKE.RoutingModel_GetDimensionResourceGroupIndex(swigCPtr, RoutingDimension.getCPtr(dimension));
    return ret;
  }

  public int AddDisjunction( long[]  indices, long penalty, long max_cardinality) {
  return operations_research_constraint_solverPINVOKE.RoutingModel_AddDisjunction__SWIG_0(swigCPtr,  indices.Length, indices , penalty, max_cardinality);
}

  public int AddDisjunction( long[]  indices, long penalty) {
  return operations_research_constraint_solverPINVOKE.RoutingModel_AddDisjunction__SWIG_1(swigCPtr,  indices.Length, indices , penalty);
}

  public int AddDisjunction( long[]  indices) {
  return operations_research_constraint_solverPINVOKE.RoutingModel_AddDisjunction__SWIG_2(swigCPtr,  indices.Length, indices );
}

  public  int[]  GetDisjunctionIndices(long index) {
  global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_GetDisjunctionIndices(swigCPtr, 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  long[]  GetDisjunctionNodeIndices(int index) {
  global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_GetDisjunctionNodeIndices(swigCPtr, index);
  Int64Vector tmpVector = null;
  if (cPtr != global::System.IntPtr.Zero) {
    tmpVector = new Int64Vector(cPtr, true);
    long[] outArray = new long[tmpVector.Count];
    tmpVector.CopyTo(outArray);
    return outArray;
  }
  return null;
}

  public long GetDisjunctionPenalty(int index) {
    long ret = operations_research_constraint_solverPINVOKE.RoutingModel_GetDisjunctionPenalty(swigCPtr, index);
    return ret;
  }

  public long GetDisjunctionMaxCardinality(int index) {
    long ret = operations_research_constraint_solverPINVOKE.RoutingModel_GetDisjunctionMaxCardinality(swigCPtr, index);
    return ret;
  }

  public int GetNumberOfDisjunctions() {
    int ret = operations_research_constraint_solverPINVOKE.RoutingModel_GetNumberOfDisjunctions(swigCPtr);
    return ret;
  }

  public bool HasMandatoryDisjunctions() {
    bool ret = operations_research_constraint_solverPINVOKE.RoutingModel_HasMandatoryDisjunctions(swigCPtr);
    return ret;
  }

  public bool HasMaxCardinalityConstrainedDisjunctions() {
    bool ret = operations_research_constraint_solverPINVOKE.RoutingModel_HasMaxCardinalityConstrainedDisjunctions(swigCPtr);
    return ret;
  }

  public void IgnoreDisjunctionsAlreadyForcedToZero() {
    operations_research_constraint_solverPINVOKE.RoutingModel_IgnoreDisjunctionsAlreadyForcedToZero(swigCPtr);
  }

  public void AddSoftSameVehicleConstraint( long[]  indices, long cost) {
    operations_research_constraint_solverPINVOKE.RoutingModel_AddSoftSameVehicleConstraint(swigCPtr,  indices.Length, indices , cost);
  }

  public void SetAllowedVehiclesForIndex( int[]  vehicles, long index) {
    operations_research_constraint_solverPINVOKE.RoutingModel_SetAllowedVehiclesForIndex(swigCPtr,  vehicles.Length, vehicles , index);
  }

  public bool IsVehicleAllowedForIndex(int vehicle, long index) {
    bool ret = operations_research_constraint_solverPINVOKE.RoutingModel_IsVehicleAllowedForIndex(swigCPtr, vehicle, index);
    return ret;
  }

  public void AddPickupAndDelivery(long pickup, long delivery) {
    operations_research_constraint_solverPINVOKE.RoutingModel_AddPickupAndDelivery(swigCPtr, pickup, delivery);
  }

  public void AddPickupAndDeliverySets(int pickup_disjunction, int delivery_disjunction) {
    operations_research_constraint_solverPINVOKE.RoutingModel_AddPickupAndDeliverySets(swigCPtr, pickup_disjunction, delivery_disjunction);
  }

  public void SetPickupAndDeliveryPolicyOfAllVehicles(int policy) {
    operations_research_constraint_solverPINVOKE.RoutingModel_SetPickupAndDeliveryPolicyOfAllVehicles(swigCPtr, policy);
  }

  public void SetPickupAndDeliveryPolicyOfVehicle(int policy, int vehicle) {
    operations_research_constraint_solverPINVOKE.RoutingModel_SetPickupAndDeliveryPolicyOfVehicle(swigCPtr, policy, vehicle);
  }

  public int GetPickupAndDeliveryPolicyOfVehicle(int vehicle) {
    int ret = operations_research_constraint_solverPINVOKE.RoutingModel_GetPickupAndDeliveryPolicyOfVehicle(swigCPtr, vehicle);
    return ret;
  }

  public int GetNumOfSingletonNodes() {
    int ret = operations_research_constraint_solverPINVOKE.RoutingModel_GetNumOfSingletonNodes(swigCPtr);
    return ret;
  }

  public void SetVisitType(long index, int type, int type_policy) {
    operations_research_constraint_solverPINVOKE.RoutingModel_SetVisitType(swigCPtr, index, type, type_policy);
  }

  public int GetVisitType(long index) {
    int ret = operations_research_constraint_solverPINVOKE.RoutingModel_GetVisitType(swigCPtr, index);
    return ret;
  }

  public  int[]  GetSingleNodesOfType(int type) {
  global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_GetSingleNodesOfType(swigCPtr, type);
  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[]  GetPairIndicesOfType(int type) {
  global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_GetPairIndicesOfType(swigCPtr, type);
  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 GetVisitTypePolicy(long index) {
    int ret = operations_research_constraint_solverPINVOKE.RoutingModel_GetVisitTypePolicy(swigCPtr, index);
    return ret;
  }

  public void CloseVisitTypes() {
    operations_research_constraint_solverPINVOKE.RoutingModel_CloseVisitTypes(swigCPtr);
  }

  public int GetNumberOfVisitTypes() {
    int ret = operations_research_constraint_solverPINVOKE.RoutingModel_GetNumberOfVisitTypes(swigCPtr);
    return ret;
  }

  public void AddHardTypeIncompatibility(int type1, int type2) {
    operations_research_constraint_solverPINVOKE.RoutingModel_AddHardTypeIncompatibility(swigCPtr, type1, type2);
  }

  public void AddTemporalTypeIncompatibility(int type1, int type2) {
    operations_research_constraint_solverPINVOKE.RoutingModel_AddTemporalTypeIncompatibility(swigCPtr, type1, type2);
  }

  public SWIGTYPE_p_absl__flat_hash_setT_int_t GetTemporalTypeIncompatibilitiesOfType(int type) {
    SWIGTYPE_p_absl__flat_hash_setT_int_t ret = new SWIGTYPE_p_absl__flat_hash_setT_int_t(operations_research_constraint_solverPINVOKE.RoutingModel_GetTemporalTypeIncompatibilitiesOfType(swigCPtr, type), false);
    return ret;
  }

  public bool HasHardTypeIncompatibilities() {
    bool ret = operations_research_constraint_solverPINVOKE.RoutingModel_HasHardTypeIncompatibilities(swigCPtr);
    return ret;
  }

  public bool HasTemporalTypeIncompatibilities() {
    bool ret = operations_research_constraint_solverPINVOKE.RoutingModel_HasTemporalTypeIncompatibilities(swigCPtr);
    return ret;
  }

  public void AddRequiredTypeAlternativesWhenAddingType(int dependent_type, SWIGTYPE_p_absl__flat_hash_setT_int_t required_type_alternatives) {
    operations_research_constraint_solverPINVOKE.RoutingModel_AddRequiredTypeAlternativesWhenAddingType(swigCPtr, dependent_type, SWIGTYPE_p_absl__flat_hash_setT_int_t.getCPtr(required_type_alternatives));
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
  }

  public void AddRequiredTypeAlternativesWhenRemovingType(int dependent_type, SWIGTYPE_p_absl__flat_hash_setT_int_t required_type_alternatives) {
    operations_research_constraint_solverPINVOKE.RoutingModel_AddRequiredTypeAlternativesWhenRemovingType(swigCPtr, dependent_type, SWIGTYPE_p_absl__flat_hash_setT_int_t.getCPtr(required_type_alternatives));
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
  }

  public SWIGTYPE_p_std__vectorT_absl__flat_hash_setT_int_t_t GetSameVehicleRequiredTypeAlternativesOfType(int type) {
    SWIGTYPE_p_std__vectorT_absl__flat_hash_setT_int_t_t ret = new SWIGTYPE_p_std__vectorT_absl__flat_hash_setT_int_t_t(operations_research_constraint_solverPINVOKE.RoutingModel_GetSameVehicleRequiredTypeAlternativesOfType(swigCPtr, type), false);
    return ret;
  }

  public SWIGTYPE_p_std__vectorT_absl__flat_hash_setT_int_t_t GetRequiredTypeAlternativesWhenAddingType(int type) {
    SWIGTYPE_p_std__vectorT_absl__flat_hash_setT_int_t_t ret = new SWIGTYPE_p_std__vectorT_absl__flat_hash_setT_int_t_t(operations_research_constraint_solverPINVOKE.RoutingModel_GetRequiredTypeAlternativesWhenAddingType(swigCPtr, type), false);
    return ret;
  }

  public SWIGTYPE_p_std__vectorT_absl__flat_hash_setT_int_t_t GetRequiredTypeAlternativesWhenRemovingType(int type) {
    SWIGTYPE_p_std__vectorT_absl__flat_hash_setT_int_t_t ret = new SWIGTYPE_p_std__vectorT_absl__flat_hash_setT_int_t_t(operations_research_constraint_solverPINVOKE.RoutingModel_GetRequiredTypeAlternativesWhenRemovingType(swigCPtr, type), false);
    return ret;
  }

  public bool HasSameVehicleTypeRequirements() {
    bool ret = operations_research_constraint_solverPINVOKE.RoutingModel_HasSameVehicleTypeRequirements(swigCPtr);
    return ret;
  }

  public bool HasTemporalTypeRequirements() {
    bool ret = operations_research_constraint_solverPINVOKE.RoutingModel_HasTemporalTypeRequirements(swigCPtr);
    return ret;
  }

  public long UnperformedPenalty(long var_index) {
    long ret = operations_research_constraint_solverPINVOKE.RoutingModel_UnperformedPenalty(swigCPtr, var_index);
    return ret;
  }

  public long UnperformedPenaltyOrValue(long default_value, long var_index) {
    long ret = operations_research_constraint_solverPINVOKE.RoutingModel_UnperformedPenaltyOrValue(swigCPtr, default_value, var_index);
    return ret;
  }

  public long GetDepot() {
    long ret = operations_research_constraint_solverPINVOKE.RoutingModel_GetDepot(swigCPtr);
    return ret;
  }

  public void SetMaximumNumberOfActiveVehicles(int max_active_vehicles) {
    operations_research_constraint_solverPINVOKE.RoutingModel_SetMaximumNumberOfActiveVehicles(swigCPtr, max_active_vehicles);
  }

  public int GetMaximumNumberOfActiveVehicles() {
    int ret = operations_research_constraint_solverPINVOKE.RoutingModel_GetMaximumNumberOfActiveVehicles(swigCPtr);
    return ret;
  }

  public void SetArcCostEvaluatorOfAllVehicles(int evaluator_index) {
    operations_research_constraint_solverPINVOKE.RoutingModel_SetArcCostEvaluatorOfAllVehicles(swigCPtr, evaluator_index);
  }

  public void SetArcCostEvaluatorOfVehicle(int evaluator_index, int vehicle) {
    operations_research_constraint_solverPINVOKE.RoutingModel_SetArcCostEvaluatorOfVehicle(swigCPtr, evaluator_index, vehicle);
  }

  public void SetFixedCostOfAllVehicles(long cost) {
    operations_research_constraint_solverPINVOKE.RoutingModel_SetFixedCostOfAllVehicles(swigCPtr, cost);
  }

  public void SetFixedCostOfVehicle(long cost, int vehicle) {
    operations_research_constraint_solverPINVOKE.RoutingModel_SetFixedCostOfVehicle(swigCPtr, cost, vehicle);
  }

  public long GetFixedCostOfVehicle(int vehicle) {
    long ret = operations_research_constraint_solverPINVOKE.RoutingModel_GetFixedCostOfVehicle(swigCPtr, vehicle);
    return ret;
  }

  public void SetAmortizedCostFactorsOfAllVehicles(long linear_cost_factor, long quadratic_cost_factor) {
    operations_research_constraint_solverPINVOKE.RoutingModel_SetAmortizedCostFactorsOfAllVehicles(swigCPtr, linear_cost_factor, quadratic_cost_factor);
  }

  public void SetAmortizedCostFactorsOfVehicle(long linear_cost_factor, long quadratic_cost_factor, int vehicle) {
    operations_research_constraint_solverPINVOKE.RoutingModel_SetAmortizedCostFactorsOfVehicle(swigCPtr, linear_cost_factor, quadratic_cost_factor, vehicle);
  }

  public  long[]  GetAmortizedLinearCostFactorOfVehicles() {
  global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_GetAmortizedLinearCostFactorOfVehicles(swigCPtr);
  Int64Vector tmpVector = null;
  if (cPtr != global::System.IntPtr.Zero) {
    tmpVector = new Int64Vector(cPtr, true);
    long[] outArray = new long[tmpVector.Count];
    tmpVector.CopyTo(outArray);
    return outArray;
  }
  return null;
}

  public  long[]  GetAmortizedQuadraticCostFactorOfVehicles() {
  global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_GetAmortizedQuadraticCostFactorOfVehicles(swigCPtr);
  Int64Vector tmpVector = null;
  if (cPtr != global::System.IntPtr.Zero) {
    tmpVector = new Int64Vector(cPtr, true);
    long[] outArray = new long[tmpVector.Count];
    tmpVector.CopyTo(outArray);
    return outArray;
  }
  return null;
}

  public void SetVehicleUsedWhenEmpty(bool is_used, int vehicle) {
    operations_research_constraint_solverPINVOKE.RoutingModel_SetVehicleUsedWhenEmpty(swigCPtr, is_used, vehicle);
  }

  public bool IsVehicleUsedWhenEmpty(int vehicle) {
    bool ret = operations_research_constraint_solverPINVOKE.RoutingModel_IsVehicleUsedWhenEmpty(swigCPtr, vehicle);
    return ret;
  }

  public void SetFirstSolutionEvaluator( LongLongToLong  evaluator) {
    operations_research_constraint_solverPINVOKE.RoutingModel_SetFirstSolutionEvaluator(swigCPtr,  StoreLongLongToLong(evaluator) );
  }

  public void AddLocalSearchOperator(LocalSearchOperator ls_operator) {
    operations_research_constraint_solverPINVOKE.RoutingModel_AddLocalSearchOperator(swigCPtr, LocalSearchOperator.getCPtr(ls_operator));
  }

  public void AddSearchMonitor(SearchMonitor monitor) {
    operations_research_constraint_solverPINVOKE.RoutingModel_AddSearchMonitor(swigCPtr, SearchMonitor.getCPtr(monitor));
  }

  public void AddAtSolutionCallback( VoidToVoid  callback) {
    operations_research_constraint_solverPINVOKE.RoutingModel_AddAtSolutionCallback(swigCPtr,  StoreVoidToVoid(callback) );
  }

  public void AddVariableMinimizedByFinalizer(IntVar var) {
    operations_research_constraint_solverPINVOKE.RoutingModel_AddVariableMinimizedByFinalizer(swigCPtr, IntVar.getCPtr(var));
  }

  public void AddVariableMaximizedByFinalizer(IntVar var) {
    operations_research_constraint_solverPINVOKE.RoutingModel_AddVariableMaximizedByFinalizer(swigCPtr, IntVar.getCPtr(var));
  }

  public void AddWeightedVariableMinimizedByFinalizer(IntVar var, long cost) {
    operations_research_constraint_solverPINVOKE.RoutingModel_AddWeightedVariableMinimizedByFinalizer(swigCPtr, IntVar.getCPtr(var), cost);
  }

  public void AddVariableTargetToFinalizer(IntVar var, long target) {
    operations_research_constraint_solverPINVOKE.RoutingModel_AddVariableTargetToFinalizer(swigCPtr, IntVar.getCPtr(var), target);
  }

  public void CloseModel() {
    operations_research_constraint_solverPINVOKE.RoutingModel_CloseModel(swigCPtr);
  }

  public void CloseModelWithParameters(Google.OrTools.ConstraintSolver.RoutingSearchParameters search_parameters) {
    operations_research_constraint_solverPINVOKE.RoutingModel_CloseModelWithParameters(swigCPtr, search_parameters.CalculateSize(), ProtoHelper.ProtoToByteArray(search_parameters));
  }

  public Assignment Solve(Assignment assignment) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_Solve__SWIG_0(swigCPtr, Assignment.getCPtr(assignment));
    Assignment ret = (cPtr == global::System.IntPtr.Zero) ? null : new Assignment(cPtr, false);
    return ret;
  }

  public Assignment Solve() {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_Solve__SWIG_1(swigCPtr);
    Assignment ret = (cPtr == global::System.IntPtr.Zero) ? null : new Assignment(cPtr, false);
    return ret;
  }

  public Assignment SolveWithParameters(Google.OrTools.ConstraintSolver.RoutingSearchParameters search_parameters) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_SolveWithParameters(swigCPtr, search_parameters.CalculateSize(), ProtoHelper.ProtoToByteArray(search_parameters));
    Assignment ret = (cPtr == global::System.IntPtr.Zero) ? null : new Assignment(cPtr, false);
    return ret;
  }

  public Assignment SolveFromAssignmentWithParameters(Assignment assignment, Google.OrTools.ConstraintSolver.RoutingSearchParameters search_parameters) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_SolveFromAssignmentWithParameters(swigCPtr, Assignment.getCPtr(assignment), search_parameters.CalculateSize(), ProtoHelper.ProtoToByteArray(search_parameters));
    Assignment ret = (cPtr == global::System.IntPtr.Zero) ? null : new Assignment(cPtr, false);
    return ret;
  }

  public Assignment SolveFromAssignmentsWithParameters(SWIGTYPE_p_std__vectorT_operations_research__Assignment_const_p_t assignments, Google.OrTools.ConstraintSolver.RoutingSearchParameters search_parameters, SWIGTYPE_p_std__vectorT_operations_research__Assignment_const_p_t solutions) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_SolveFromAssignmentsWithParameters__SWIG_0(swigCPtr, SWIGTYPE_p_std__vectorT_operations_research__Assignment_const_p_t.getCPtr(assignments), search_parameters.CalculateSize(), ProtoHelper.ProtoToByteArray(search_parameters), SWIGTYPE_p_std__vectorT_operations_research__Assignment_const_p_t.getCPtr(solutions));
    Assignment ret = (cPtr == global::System.IntPtr.Zero) ? null : new Assignment(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public Assignment SolveFromAssignmentsWithParameters(SWIGTYPE_p_std__vectorT_operations_research__Assignment_const_p_t assignments, Google.OrTools.ConstraintSolver.RoutingSearchParameters search_parameters) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_SolveFromAssignmentsWithParameters__SWIG_1(swigCPtr, SWIGTYPE_p_std__vectorT_operations_research__Assignment_const_p_t.getCPtr(assignments), search_parameters.CalculateSize(), ProtoHelper.ProtoToByteArray(search_parameters));
    Assignment ret = (cPtr == global::System.IntPtr.Zero) ? null : new Assignment(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public void SetAssignmentFromOtherModelAssignment(Assignment target_assignment, RoutingModel source_model, Assignment source_assignment) {
    operations_research_constraint_solverPINVOKE.RoutingModel_SetAssignmentFromOtherModelAssignment(swigCPtr, Assignment.getCPtr(target_assignment), RoutingModel.getCPtr(source_model), Assignment.getCPtr(source_assignment));
  }

  public long ComputeLowerBound() {
    long ret = operations_research_constraint_solverPINVOKE.RoutingModel_ComputeLowerBound(swigCPtr);
    return ret;
  }

  public int GetStatus() {
    int ret = operations_research_constraint_solverPINVOKE.RoutingModel_GetStatus(swigCPtr);
    return ret;
  }

  public IntVar ApplyLocks( long[]  locks) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_ApplyLocks(swigCPtr,  locks.Length, locks );
    IntVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntVar(cPtr, false);
    return ret;
  }

  public bool ApplyLocksToAllVehicles( long[][]  locks, bool close_routes) {
    bool ret = operations_research_constraint_solverPINVOKE.RoutingModel_ApplyLocksToAllVehicles(swigCPtr, 
  locks.GetLength(0),
  NestedArrayHelper.GetArraySecondSize(locks),
  NestedArrayHelper.GetFlatArray(locks)
, close_routes);
    return ret;
  }

  public Assignment PreAssignment() {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_PreAssignment(swigCPtr);
    Assignment ret = (cPtr == global::System.IntPtr.Zero) ? null : new Assignment(cPtr, false);
    return ret;
  }

  public Assignment MutablePreAssignment() {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_MutablePreAssignment(swigCPtr);
    Assignment ret = (cPtr == global::System.IntPtr.Zero) ? null : new Assignment(cPtr, false);
    return ret;
  }

  public bool WriteAssignment(string file_name) {
    bool ret = operations_research_constraint_solverPINVOKE.RoutingModel_WriteAssignment(swigCPtr, file_name);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public Assignment ReadAssignment(string file_name) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_ReadAssignment(swigCPtr, file_name);
    Assignment ret = (cPtr == global::System.IntPtr.Zero) ? null : new Assignment(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public Assignment RestoreAssignment(Assignment solution) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_RestoreAssignment(swigCPtr, Assignment.getCPtr(solution));
    Assignment ret = (cPtr == global::System.IntPtr.Zero) ? null : new Assignment(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public Assignment ReadAssignmentFromRoutes( long[][]  routes, bool ignore_inactive_indices) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_ReadAssignmentFromRoutes(swigCPtr, 
  routes.GetLength(0),
  NestedArrayHelper.GetArraySecondSize(routes),
  NestedArrayHelper.GetFlatArray(routes)
, ignore_inactive_indices);
    Assignment ret = (cPtr == global::System.IntPtr.Zero) ? null : new Assignment(cPtr, false);
    return ret;
  }

  public bool RoutesToAssignment( long[][]  routes, bool ignore_inactive_indices, bool close_routes, Assignment assignment) {
    bool ret = operations_research_constraint_solverPINVOKE.RoutingModel_RoutesToAssignment(swigCPtr, 
  routes.GetLength(0),
  NestedArrayHelper.GetArraySecondSize(routes),
  NestedArrayHelper.GetFlatArray(routes)
, ignore_inactive_indices, close_routes, Assignment.getCPtr(assignment));
    return ret;
  }

  public void AssignmentToRoutes(Assignment assignment,  long[][]  routes) {
    operations_research_constraint_solverPINVOKE.RoutingModel_AssignmentToRoutes(swigCPtr, Assignment.getCPtr(assignment), 
  routes.GetLength(0),
  NestedArrayHelper.GetArraySecondSize(routes),
  NestedArrayHelper.GetFlatArray(routes)
);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
  }

  public Assignment CompactAssignment(Assignment assignment) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_CompactAssignment(swigCPtr, Assignment.getCPtr(assignment));
    Assignment ret = (cPtr == global::System.IntPtr.Zero) ? null : new Assignment(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public Assignment CompactAndCheckAssignment(Assignment assignment) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_CompactAndCheckAssignment(swigCPtr, Assignment.getCPtr(assignment));
    Assignment ret = (cPtr == global::System.IntPtr.Zero) ? null : new Assignment(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public void AddToAssignment(IntVar var) {
    operations_research_constraint_solverPINVOKE.RoutingModel_AddToAssignment(swigCPtr, IntVar.getCPtr(var));
  }

  public void AddIntervalToAssignment(IntervalVar interval) {
    operations_research_constraint_solverPINVOKE.RoutingModel_AddIntervalToAssignment(swigCPtr, IntervalVar.getCPtr(interval));
  }

  public void AddLocalSearchFilter(LocalSearchFilter filter) {
    operations_research_constraint_solverPINVOKE.RoutingModel_AddLocalSearchFilter(swigCPtr, LocalSearchFilter.getCPtr(filter));
  }

  public long Start(int vehicle) {
    long ret = operations_research_constraint_solverPINVOKE.RoutingModel_Start(swigCPtr, vehicle);
    return ret;
  }

  public long End(int vehicle) {
    long ret = operations_research_constraint_solverPINVOKE.RoutingModel_End(swigCPtr, vehicle);
    return ret;
  }

  public bool IsStart(long index) {
    bool ret = operations_research_constraint_solverPINVOKE.RoutingModel_IsStart(swigCPtr, index);
    return ret;
  }

  public bool IsEnd(long index) {
    bool ret = operations_research_constraint_solverPINVOKE.RoutingModel_IsEnd(swigCPtr, index);
    return ret;
  }

  public int VehicleIndex(long index) {
    int ret = operations_research_constraint_solverPINVOKE.RoutingModel_VehicleIndex(swigCPtr, index);
    return ret;
  }

  public long Next(Assignment assignment, long index) {
    long ret = operations_research_constraint_solverPINVOKE.RoutingModel_Next(swigCPtr, Assignment.getCPtr(assignment), index);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public bool IsVehicleUsed(Assignment assignment, int vehicle) {
    bool ret = operations_research_constraint_solverPINVOKE.RoutingModel_IsVehicleUsed(swigCPtr, Assignment.getCPtr(assignment), vehicle);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public IntVarVector Nexts() {
    IntVarVector ret = new IntVarVector(operations_research_constraint_solverPINVOKE.RoutingModel_Nexts(swigCPtr), false);
    return ret;
  }

  public IntVarVector VehicleVars() {
    IntVarVector ret = new IntVarVector(operations_research_constraint_solverPINVOKE.RoutingModel_VehicleVars(swigCPtr), false);
    return ret;
  }

  public IntVarVector ResourceVars(int resource_group) {
    IntVarVector ret = new IntVarVector(operations_research_constraint_solverPINVOKE.RoutingModel_ResourceVars(swigCPtr, resource_group), false);
    return ret;
  }

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

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

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

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

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

  public IntVar ResourceVar(int vehicle, int resource_group) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_ResourceVar(swigCPtr, vehicle, resource_group);
    IntVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntVar(cPtr, false);
    return ret;
  }

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

  public long GetArcCostForVehicle(long from_index, long to_index, long vehicle) {
    long ret = operations_research_constraint_solverPINVOKE.RoutingModel_GetArcCostForVehicle(swigCPtr, from_index, to_index, vehicle);
    return ret;
  }

  public bool CostsAreHomogeneousAcrossVehicles() {
    bool ret = operations_research_constraint_solverPINVOKE.RoutingModel_CostsAreHomogeneousAcrossVehicles(swigCPtr);
    return ret;
  }

  public long GetHomogeneousCost(long from_index, long to_index) {
    long ret = operations_research_constraint_solverPINVOKE.RoutingModel_GetHomogeneousCost(swigCPtr, from_index, to_index);
    return ret;
  }

  public long GetArcCostForFirstSolution(long from_index, long to_index) {
    long ret = operations_research_constraint_solverPINVOKE.RoutingModel_GetArcCostForFirstSolution(swigCPtr, from_index, to_index);
    return ret;
  }

  public long GetArcCostForClass(long from_index, long to_index, long cost_class_index) {
    long ret = operations_research_constraint_solverPINVOKE.RoutingModel_GetArcCostForClass(swigCPtr, from_index, to_index, cost_class_index);
    return ret;
  }

  public int GetCostClassIndexOfVehicle(long vehicle) {
  return operations_research_constraint_solverPINVOKE.RoutingModel_GetCostClassIndexOfVehicle(swigCPtr, vehicle);
}

  public bool HasVehicleWithCostClassIndex(int cost_class_index) {
    bool ret = operations_research_constraint_solverPINVOKE.RoutingModel_HasVehicleWithCostClassIndex(swigCPtr, cost_class_index);
    return ret;
  }

  public int GetCostClassesCount() {
    int ret = operations_research_constraint_solverPINVOKE.RoutingModel_GetCostClassesCount(swigCPtr);
    return ret;
  }

  public int GetNonZeroCostClassesCount() {
    int ret = operations_research_constraint_solverPINVOKE.RoutingModel_GetNonZeroCostClassesCount(swigCPtr);
    return ret;
  }

  public int GetVehicleClassIndexOfVehicle(long vehicle) {
  return operations_research_constraint_solverPINVOKE.RoutingModel_GetVehicleClassIndexOfVehicle(swigCPtr, vehicle);
}

  public int GetVehicleOfClass(int vehicle_class) {
    int ret = operations_research_constraint_solverPINVOKE.RoutingModel_GetVehicleOfClass(swigCPtr, vehicle_class);
    return ret;
  }

  public int GetVehicleClassesCount() {
    int ret = operations_research_constraint_solverPINVOKE.RoutingModel_GetVehicleClassesCount(swigCPtr);
    return ret;
  }

  public  int[]  GetSameVehicleIndicesOfIndex(int node) {
  global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_GetSameVehicleIndicesOfIndex(swigCPtr, node);
  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 RoutingModel.VehicleTypeContainer GetVehicleTypeContainer() {
    RoutingModel.VehicleTypeContainer ret = new RoutingModel.VehicleTypeContainer(operations_research_constraint_solverPINVOKE.RoutingModel_GetVehicleTypeContainer(swigCPtr), false);
    return ret;
  }

  public bool ArcIsMoreConstrainedThanArc(long from, long to1, long to2) {
    bool ret = operations_research_constraint_solverPINVOKE.RoutingModel_ArcIsMoreConstrainedThanArc(swigCPtr, from, to1, to2);
    return ret;
  }

  public string DebugOutputAssignment(Assignment solution_assignment, string dimension_to_print) {
    string ret = operations_research_constraint_solverPINVOKE.RoutingModel_DebugOutputAssignment(swigCPtr, Assignment.getCPtr(solution_assignment), dimension_to_print);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public Solver solver() {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_solver(swigCPtr);
    Solver ret = (cPtr == global::System.IntPtr.Zero) ? null : new Solver(cPtr, false);
    return ret;
  }

  public bool CheckLimit() {
    bool ret = operations_research_constraint_solverPINVOKE.RoutingModel_CheckLimit(swigCPtr);
    return ret;
  }

  public int Nodes() {
    int ret = operations_research_constraint_solverPINVOKE.RoutingModel_Nodes(swigCPtr);
    return ret;
  }

  public int Vehicles() {
    int ret = operations_research_constraint_solverPINVOKE.RoutingModel_Vehicles(swigCPtr);
    return ret;
  }

  public long Size() {
    long ret = operations_research_constraint_solverPINVOKE.RoutingModel_Size(swigCPtr);
    return ret;
  }

  public long GetNumberOfDecisionsInFirstSolution(Google.OrTools.ConstraintSolver.RoutingSearchParameters search_parameters) {
    long ret = operations_research_constraint_solverPINVOKE.RoutingModel_GetNumberOfDecisionsInFirstSolution(swigCPtr, search_parameters.CalculateSize(), ProtoHelper.ProtoToByteArray(search_parameters));
    return ret;
  }

  public long GetNumberOfRejectsInFirstSolution(Google.OrTools.ConstraintSolver.RoutingSearchParameters search_parameters) {
    long ret = operations_research_constraint_solverPINVOKE.RoutingModel_GetNumberOfRejectsInFirstSolution(swigCPtr, search_parameters.CalculateSize(), ProtoHelper.ProtoToByteArray(search_parameters));
    return ret;
  }

  public bool IsMatchingModel() {
    bool ret = operations_research_constraint_solverPINVOKE.RoutingModel_IsMatchingModel(swigCPtr);
    return ret;
  }

  public DecisionBuilder MakeGuidedSlackFinalizer(RoutingDimension dimension,  LongToLong  initializer) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_MakeGuidedSlackFinalizer(swigCPtr, RoutingDimension.getCPtr(dimension),  StoreLongToLong(initializer) );
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    return ret;
  }

  public DecisionBuilder MakeSelfDependentDimensionFinalizer(RoutingDimension dimension) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_MakeSelfDependentDimensionFinalizer(swigCPtr, RoutingDimension.getCPtr(dimension));
    DecisionBuilder ret = (cPtr == global::System.IntPtr.Zero) ? null : new DecisionBuilder(cPtr, false);
    return ret;
  }

  // Status 
  public static readonly int ROUTING_NOT_SOLVED = operations_research_constraint_solverPINVOKE.RoutingModel_ROUTING_NOT_SOLVED_get();
  public static readonly int ROUTING_SUCCESS = operations_research_constraint_solverPINVOKE.RoutingModel_ROUTING_SUCCESS_get();
  public static readonly int ROUTING_FAIL = operations_research_constraint_solverPINVOKE.RoutingModel_ROUTING_FAIL_get();
  public static readonly int ROUTING_FAIL_TIMEOUT = operations_research_constraint_solverPINVOKE.RoutingModel_ROUTING_FAIL_TIMEOUT_get();
  public static readonly int ROUTING_INVALID = operations_research_constraint_solverPINVOKE.RoutingModel_ROUTING_INVALID_get();

  // PickupAndDeliveryPolicy 
  public static readonly int PICKUP_AND_DELIVERY_NO_ORDER = operations_research_constraint_solverPINVOKE.RoutingModel_PICKUP_AND_DELIVERY_NO_ORDER_get();
  public static readonly int PICKUP_AND_DELIVERY_LIFO = operations_research_constraint_solverPINVOKE.RoutingModel_PICKUP_AND_DELIVERY_LIFO_get();
  public static readonly int PICKUP_AND_DELIVERY_FIFO = operations_research_constraint_solverPINVOKE.RoutingModel_PICKUP_AND_DELIVERY_FIFO_get();

  // VisitTypePolicy 
  public static readonly int TYPE_ADDED_TO_VEHICLE = operations_research_constraint_solverPINVOKE.RoutingModel_TYPE_ADDED_TO_VEHICLE_get();
  public static readonly int ADDED_TYPE_REMOVED_FROM_VEHICLE = operations_research_constraint_solverPINVOKE.RoutingModel_ADDED_TYPE_REMOVED_FROM_VEHICLE_get();
  public static readonly int TYPE_ON_VEHICLE_UP_TO_VISIT = operations_research_constraint_solverPINVOKE.RoutingModel_TYPE_ON_VEHICLE_UP_TO_VISIT_get();
  public static readonly int TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED = operations_research_constraint_solverPINVOKE.RoutingModel_TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED_get();

}

}