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.2
//
// 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 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 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 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 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__SWIG_0(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[]  GetDisjunctionIndices(int index) {
  global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_GetDisjunctionIndices__SWIG_1(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 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 ConsiderEmptyRouteCostsForVehicle(bool consider_costs, int vehicle) {
    operations_research_constraint_solverPINVOKE.RoutingModel_ConsiderEmptyRouteCostsForVehicle(swigCPtr, consider_costs, vehicle);
  }
 
  public bool AreEmptyRouteCostsConsideredForVehicle(int vehicle) {
    bool ret = operations_research_constraint_solverPINVOKE.RoutingModel_AreEmptyRouteCostsConsideredForVehicle(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 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 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 VehicleCostsConsideredVar(int vehicle) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_VehicleCostsConsideredVar(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 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 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();
 
}
 
}