RoutingModel.cs

Go to the documentation of this file.

//------------------------------------------------------------------------------
// <auto-generated />
//
// This file was automatically generated by SWIG (https://www.swig.org).
// Version 4.3.0
//
// Do not make changes to this file unless you know what you are doing - modify
// the SWIG interface file instead.
//------------------------------------------------------------------------------
 
namespace Google.OrTools.ConstraintSolver {
 
using System;
using System.Collections.Generic;
using Domain = Google.OrTools.Util.Domain;
 
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;
  }
 
  internal static global::System.Runtime.InteropServices.HandleRef swigRelease(RoutingModel obj) {
    if (obj != null) {
      if (!obj.swigCMemOwn)
        throw new global::System.ApplicationException("Cannot release ownership as memory is not owned");
      global::System.Runtime.InteropServices.HandleRef ptr = obj.swigCPtr;
      obj.swigCMemOwn = false;
      obj.Dispose();
      return ptr;
    } else {
      return new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
    }
  }
 
  ~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;
    }
  
    internal static global::System.Runtime.InteropServices.HandleRef swigRelease(VehicleTypeContainer obj) {
      if (obj != null) {
        if (!obj.swigCMemOwn)
          throw new global::System.ApplicationException("Cannot release ownership as memory is not owned");
        global::System.Runtime.InteropServices.HandleRef ptr = obj.swigCPtr;
        obj.swigCMemOwn = false;
        obj.Dispose();
        return ptr;
      } else {
        return new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
      }
    }
  
    ~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;
        }
      
        internal static global::System.Runtime.InteropServices.HandleRef swigRelease(VehicleClassEntry obj) {
          if (obj != null) {
            if (!obj.swigCMemOwn)
              throw new global::System.ApplicationException("Cannot release ownership as memory is not owned");
            global::System.Runtime.InteropServices.HandleRef ptr = obj.swigCPtr;
            obj.swigCMemOwn = false;
            obj.Dispose();
            return ptr;
          } else {
            return new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
          }
        }
      
        ~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;
    }
  
    internal static global::System.Runtime.InteropServices.HandleRef swigRelease(ResourceGroup obj) {
      if (obj != null) {
        if (!obj.swigCMemOwn)
          throw new global::System.ApplicationException("Cannot release ownership as memory is not owned");
        global::System.Runtime.InteropServices.HandleRef ptr = obj.swigCPtr;
        obj.swigCMemOwn = false;
        obj.Dispose();
        return ptr;
      } else {
        return new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
      }
    }
  
    ~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;
        }
      
        internal static global::System.Runtime.InteropServices.HandleRef swigRelease(Attributes obj) {
          if (obj != null) {
            if (!obj.swigCMemOwn)
              throw new global::System.ApplicationException("Cannot release ownership as memory is not owned");
            global::System.Runtime.InteropServices.HandleRef ptr = obj.swigCPtr;
            obj.swigCMemOwn = false;
            obj.Dispose();
            return ptr;
          } else {
            return new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
          }
        }
      
        ~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;
        }
      
        internal static global::System.Runtime.InteropServices.HandleRef swigRelease(Resource obj) {
          if (obj != null) {
            if (!obj.swigCMemOwn)
              throw new global::System.ApplicationException("Cannot release ownership as memory is not owned");
            global::System.Runtime.InteropServices.HandleRef ptr = obj.swigCPtr;
            obj.swigCMemOwn = false;
            obj.Dispose();
            return ptr;
          } else {
            return new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
          }
        }
      
        ~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 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 void SetAllowedResourcesForVehicle(int vehicle,  int[]  allowed_resource_indices) {
      operations_research_constraint_solverPINVOKE.RoutingModel_ResourceGroup_SetAllowedResourcesForVehicle(swigCPtr, vehicle,  allowed_resource_indices.Length, allowed_resource_indices );
    }
  
    public void ClearAllowedResourcesForVehicle(int vehicle) {
      operations_research_constraint_solverPINVOKE.RoutingModel_ResourceGroup_ClearAllowedResourcesForVehicle(swigCPtr, vehicle);
    }
  
    public SWIGTYPE_p_absl__flat_hash_setT_int_t GetResourcesMarkedAllowedForVehicle(int vehicle) {
      SWIGTYPE_p_absl__flat_hash_setT_int_t ret = new SWIGTYPE_p_absl__flat_hash_setT_int_t(operations_research_constraint_solverPINVOKE.RoutingModel_ResourceGroup_GetResourcesMarkedAllowedForVehicle(swigCPtr, vehicle), false);
      return ret;
    }
  
    public bool IsResourceAllowedForVehicle(int resource, int vehicle) {
      bool ret = operations_research_constraint_solverPINVOKE.RoutingModel_ResourceGroup_IsResourceAllowedForVehicle(swigCPtr, resource, 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_RoutingDimensionIndex_t GetAffectedDimensionIndices() {
      SWIGTYPE_p_absl__flat_hash_setT_RoutingDimensionIndex_t ret = new SWIGTYPE_p_absl__flat_hash_setT_RoutingDimensionIndex_t(operations_research_constraint_solverPINVOKE.RoutingModel_ResourceGroup_GetAffectedDimensionIndices(swigCPtr), false);
      return ret;
    }
  
    public int GetResourceClassesCount() {
      int ret = operations_research_constraint_solverPINVOKE.RoutingModel_ResourceGroup_GetResourceClassesCount(swigCPtr);
      return ret;
    }
  
    public  int[]  GetResourceIndicesInClass(int resource_class) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_ResourceGroup_GetResourceIndicesInClass(swigCPtr, resource_class);
    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 SWIGTYPE_p_util_intops__StrongVectorT_operations_research__RoutingModel__ResourceClassIndex_std__vectorT_int_t_t GetResourceIndicesPerClass() {
      SWIGTYPE_p_util_intops__StrongVectorT_operations_research__RoutingModel__ResourceClassIndex_std__vectorT_int_t_t ret = new SWIGTYPE_p_util_intops__StrongVectorT_operations_research__RoutingModel__ResourceClassIndex_std__vectorT_int_t_t(operations_research_constraint_solverPINVOKE.RoutingModel_ResourceGroup_GetResourceIndicesPerClass(swigCPtr), false);
      return ret;
    }
  
    public int GetResourceClassIndex(int resource_index) {
    return operations_research_constraint_solverPINVOKE.RoutingModel_ResourceGroup_GetResourceClassIndex(swigCPtr, resource_index);
  }
  
    public RoutingModel.ResourceGroup.Attributes GetDimensionAttributesForClass(RoutingDimension dimension, int rc_index) {
      RoutingModel.ResourceGroup.Attributes ret = new RoutingModel.ResourceGroup.Attributes(operations_research_constraint_solverPINVOKE.RoutingModel_ResourceGroup_GetDimensionAttributesForClass(swigCPtr, RoutingDimension.getCPtr(dimension), rc_index), false);
      return ret;
    }
  
    public int Size() {
      int ret = operations_research_constraint_solverPINVOKE.RoutingModel_ResourceGroup_Size(swigCPtr);
      return ret;
    }
  
    public int Index() {
      int ret = operations_research_constraint_solverPINVOKE.RoutingModel_ResourceGroup_Index(swigCPtr);
      return ret;
    }
  
  }
 
  public partial class VariableValuePair : global::System.IDisposable {
    private global::System.Runtime.InteropServices.HandleRef swigCPtr;
    protected bool swigCMemOwn;
  
    internal VariableValuePair(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(VariableValuePair obj) {
      return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
    }
  
    internal static global::System.Runtime.InteropServices.HandleRef swigRelease(VariableValuePair obj) {
      if (obj != null) {
        if (!obj.swigCMemOwn)
          throw new global::System.ApplicationException("Cannot release ownership as memory is not owned");
        global::System.Runtime.InteropServices.HandleRef ptr = obj.swigCPtr;
        obj.swigCMemOwn = false;
        obj.Dispose();
        return ptr;
      } else {
        return new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
      }
    }
  
    ~VariableValuePair() {
      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_VariableValuePair(swigCPtr);
          }
          swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
        }
      }
    }
  
    public int var_index {
      set {
        operations_research_constraint_solverPINVOKE.RoutingModel_VariableValuePair_var_index_set(swigCPtr, value);
      } 
      get {
        int ret = operations_research_constraint_solverPINVOKE.RoutingModel_VariableValuePair_var_index_get(swigCPtr);
        return ret;
      } 
    }
  
    public long value {
      set {
        operations_research_constraint_solverPINVOKE.RoutingModel_VariableValuePair_value_set(swigCPtr, value);
      } 
      get {
        long ret = operations_research_constraint_solverPINVOKE.RoutingModel_VariableValuePair_value_get(swigCPtr);
        return ret;
      } 
    }
  
    public VariableValuePair() : this(operations_research_constraint_solverPINVOKE.new_RoutingModel_VariableValuePair(), true) {
    }
  
  }
 
  public partial class SecondaryOptimizer : global::System.IDisposable {
    private global::System.Runtime.InteropServices.HandleRef swigCPtr;
    protected bool swigCMemOwn;
  
    internal SecondaryOptimizer(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(SecondaryOptimizer obj) {
      return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
    }
  
    internal static global::System.Runtime.InteropServices.HandleRef swigRelease(SecondaryOptimizer obj) {
      if (obj != null) {
        if (!obj.swigCMemOwn)
          throw new global::System.ApplicationException("Cannot release ownership as memory is not owned");
        global::System.Runtime.InteropServices.HandleRef ptr = obj.swigCPtr;
        obj.swigCMemOwn = false;
        obj.Dispose();
        return ptr;
      } else {
        return new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
      }
    }
  
    ~SecondaryOptimizer() {
      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_SecondaryOptimizer(swigCPtr);
          }
          swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
        }
      }
    }
  
    public SecondaryOptimizer(RoutingModel model, Google.OrTools.ConstraintSolver.RoutingSearchParameters search_parameters, long solve_period) : this(operations_research_constraint_solverPINVOKE.new_RoutingModel_SecondaryOptimizer(RoutingModel.getCPtr(model), ProtoHelper.ProtoToByteArray(search_parameters, out var buffer), buffer, solve_period), true) {
    }
  
    public bool Solve(SWIGTYPE_p_std__vectorT_operations_research__RoutingModel__VariableValuePair_t in_state, SWIGTYPE_p_std__vectorT_operations_research__RoutingModel__VariableValuePair_t out_state) {
      bool ret = operations_research_constraint_solverPINVOKE.RoutingModel_SecondaryOptimizer_Solve(swigCPtr, SWIGTYPE_p_std__vectorT_operations_research__RoutingModel__VariableValuePair_t.getCPtr(in_state), SWIGTYPE_p_std__vectorT_operations_research__RoutingModel__VariableValuePair_t.getCPtr(out_state));
      if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
      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), ProtoHelper.ProtoToByteArray(parameters, out var buffer), buffer), 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 sign) {
    int ret = operations_research_constraint_solverPINVOKE.RoutingModel_RegisterUnaryTransitCallback__SWIG_0(swigCPtr,  StoreLongToLong(callback) , sign);
    return ret;
  }
 
  public int RegisterUnaryTransitCallback( LongToLong  callback) {
    int ret = operations_research_constraint_solverPINVOKE.RoutingModel_RegisterUnaryTransitCallback__SWIG_1(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 sign) {
    int ret = operations_research_constraint_solverPINVOKE.RoutingModel_RegisterTransitCallback__SWIG_0(swigCPtr,  StoreLongLongToLong(callback) , sign);
    return ret;
  }
 
  public int RegisterTransitCallback( LongLongToLong  callback) {
    int ret = operations_research_constraint_solverPINVOKE.RoutingModel_RegisterTransitCallback__SWIG_1(swigCPtr,  StoreLongLongToLong(callback) );
    return ret;
  }
 
  public int RegisterCumulDependentTransitCallback(SWIGTYPE_p_std__functionT_FloatSlopePiecewiseLinearFunction_const_pflong_longF_t callback) {
    int ret = operations_research_constraint_solverPINVOKE.RoutingModel_RegisterCumulDependentTransitCallback(swigCPtr, SWIGTYPE_p_std__functionT_FloatSlopePiecewiseLinearFunction_const_pflong_longF_t.getCPtr(callback));
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public SWIGTYPE_p_std__functionT_FloatSlopePiecewiseLinearFunction_const_pflong_longF_t CumulDependentTransitCallback(int callback_index) {
    SWIGTYPE_p_std__functionT_FloatSlopePiecewiseLinearFunction_const_pflong_longF_t ret = new SWIGTYPE_p_std__functionT_FloatSlopePiecewiseLinearFunction_const_pflong_longF_t(operations_research_constraint_solverPINVOKE.RoutingModel_CumulDependentTransitCallback(swigCPtr, callback_index), false);
    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 bool AddDimensionWithCumulDependentVehicleTransitAndCapacity( int[]  fixed_evaluator_indices,  int[]  cumul_dependent_evaluator_indices, long slack_max,  long[]  vehicle_capacities, bool fix_start_cumul_to_zero, string name) {
    bool ret = operations_research_constraint_solverPINVOKE.RoutingModel_AddDimensionWithCumulDependentVehicleTransitAndCapacity(swigCPtr,  fixed_evaluator_indices.Length, fixed_evaluator_indices ,  cumul_dependent_evaluator_indices.Length, cumul_dependent_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 SWIGTYPE_p_std__vectorT_operations_research__RoutingDimension_p_t GetUnaryDimensions() {
    SWIGTYPE_p_std__vectorT_operations_research__RoutingDimension_p_t ret = new SWIGTYPE_p_std__vectorT_operations_research__RoutingDimension_p_t(operations_research_constraint_solverPINVOKE.RoutingModel_GetUnaryDimensions(swigCPtr), true);
    return ret;
  }
 
  public SWIGTYPE_p_std__vectorT_operations_research__RoutingDimension_const_p_t GetDimensionsWithGlobalCumulOptimizers() {
    SWIGTYPE_p_std__vectorT_operations_research__RoutingDimension_const_p_t ret = new SWIGTYPE_p_std__vectorT_operations_research__RoutingDimension_const_p_t(operations_research_constraint_solverPINVOKE.RoutingModel_GetDimensionsWithGlobalCumulOptimizers(swigCPtr), true);
    return ret;
  }
 
  public SWIGTYPE_p_std__vectorT_operations_research__RoutingDimension_const_p_t GetDimensionsWithLocalCumulOptimizers() {
    SWIGTYPE_p_std__vectorT_operations_research__RoutingDimension_const_p_t ret = new SWIGTYPE_p_std__vectorT_operations_research__RoutingDimension_const_p_t(operations_research_constraint_solverPINVOKE.RoutingModel_GetDimensionsWithLocalCumulOptimizers(swigCPtr), true);
    return ret;
  }
 
  public bool HasGlobalCumulOptimizer(RoutingDimension dimension) {
    bool ret = operations_research_constraint_solverPINVOKE.RoutingModel_HasGlobalCumulOptimizer(swigCPtr, RoutingDimension.getCPtr(dimension));
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public bool HasLocalCumulOptimizer(RoutingDimension dimension) {
    bool ret = operations_research_constraint_solverPINVOKE.RoutingModel_HasLocalCumulOptimizer(swigCPtr, RoutingDimension.getCPtr(dimension));
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public SWIGTYPE_p_operations_research__GlobalDimensionCumulOptimizer GetMutableGlobalCumulLPOptimizer(RoutingDimension dimension) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_GetMutableGlobalCumulLPOptimizer(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 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 SWIGTYPE_p_operations_research__LocalDimensionCumulOptimizer GetMutableLocalCumulLPOptimizer(RoutingDimension dimension) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_GetMutableLocalCumulLPOptimizer(swigCPtr, RoutingDimension.getCPtr(dimension));
    SWIGTYPE_p_operations_research__LocalDimensionCumulOptimizer ret = (cPtr == global::System.IntPtr.Zero) ? null : new SWIGTYPE_p_operations_research__LocalDimensionCumulOptimizer(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 RoutingModel.ResourceGroup AddResourceGroup() {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_AddResourceGroup(swigCPtr);
    RoutingModel.ResourceGroup ret = (cPtr == global::System.IntPtr.Zero) ? null : new RoutingModel.ResourceGroup(cPtr, false);
    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, int penalty_cost_behavior) {
  return operations_research_constraint_solverPINVOKE.RoutingModel_AddDisjunction__SWIG_0(swigCPtr,  indices.Length, indices , penalty, max_cardinality, penalty_cost_behavior);
}
 
  public int AddDisjunction( long[]  indices, long penalty, long max_cardinality) {
  return operations_research_constraint_solverPINVOKE.RoutingModel_AddDisjunction__SWIG_1(swigCPtr,  indices.Length, indices , penalty, max_cardinality);
}
 
  public int AddDisjunction( long[]  indices, long penalty) {
  return operations_research_constraint_solverPINVOKE.RoutingModel_AddDisjunction__SWIG_2(swigCPtr,  indices.Length, indices , penalty);
}
 
  public int AddDisjunction( long[]  indices) {
  return operations_research_constraint_solverPINVOKE.RoutingModel_AddDisjunction__SWIG_3(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 GetDisjunctionPenaltyCostBehavior(int index) {
    int ret = operations_research_constraint_solverPINVOKE.RoutingModel_GetDisjunctionPenaltyCostBehavior(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 partial class PickupDeliveryPosition : global::System.IDisposable {
    private global::System.Runtime.InteropServices.HandleRef swigCPtr;
    protected bool swigCMemOwn;
  
    internal PickupDeliveryPosition(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(PickupDeliveryPosition obj) {
      return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
    }
  
    internal static global::System.Runtime.InteropServices.HandleRef swigRelease(PickupDeliveryPosition obj) {
      if (obj != null) {
        if (!obj.swigCMemOwn)
          throw new global::System.ApplicationException("Cannot release ownership as memory is not owned");
        global::System.Runtime.InteropServices.HandleRef ptr = obj.swigCPtr;
        obj.swigCMemOwn = false;
        obj.Dispose();
        return ptr;
      } else {
        return new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
      }
    }
  
    ~PickupDeliveryPosition() {
      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_PickupDeliveryPosition(swigCPtr);
          }
          swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
        }
      }
    }
  
    public int pd_pair_index {
      set {
        operations_research_constraint_solverPINVOKE.RoutingModel_PickupDeliveryPosition_pd_pair_index_set(swigCPtr, value);
      } 
      get {
        int ret = operations_research_constraint_solverPINVOKE.RoutingModel_PickupDeliveryPosition_pd_pair_index_get(swigCPtr);
        return ret;
      } 
    }
  
    public int alternative_index {
      set {
        operations_research_constraint_solverPINVOKE.RoutingModel_PickupDeliveryPosition_alternative_index_set(swigCPtr, value);
      } 
      get {
        int ret = operations_research_constraint_solverPINVOKE.RoutingModel_PickupDeliveryPosition_alternative_index_get(swigCPtr);
        return ret;
      } 
    }
  
    public PickupDeliveryPosition() : this(operations_research_constraint_solverPINVOKE.new_RoutingModel_PickupDeliveryPosition(), true) {
    }
  
  }
 
  public SWIGTYPE_p_std__optionalT_operations_research__RoutingModel__PickupDeliveryPosition_t GetPickupPosition(long node_index) {
    SWIGTYPE_p_std__optionalT_operations_research__RoutingModel__PickupDeliveryPosition_t ret = new SWIGTYPE_p_std__optionalT_operations_research__RoutingModel__PickupDeliveryPosition_t(operations_research_constraint_solverPINVOKE.RoutingModel_GetPickupPosition(swigCPtr, node_index), true);
    return ret;
  }
 
  public SWIGTYPE_p_std__optionalT_operations_research__RoutingModel__PickupDeliveryPosition_t GetDeliveryPosition(long node_index) {
    SWIGTYPE_p_std__optionalT_operations_research__RoutingModel__PickupDeliveryPosition_t ret = new SWIGTYPE_p_std__optionalT_operations_research__RoutingModel__PickupDeliveryPosition_t(operations_research_constraint_solverPINVOKE.RoutingModel_GetDeliveryPosition(swigCPtr, node_index), true);
    return ret;
  }
 
  public bool IsPickup(long node_index) {
    bool ret = operations_research_constraint_solverPINVOKE.RoutingModel_IsPickup(swigCPtr, node_index);
    return ret;
  }
 
  public bool IsDelivery(long node_index) {
    bool ret = operations_research_constraint_solverPINVOKE.RoutingModel_IsDelivery(swigCPtr, node_index);
    return ret;
  }
 
  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 SWIGTYPE_p_std__optionalT_long_t GetFirstMatchingPickupDeliverySibling(long node, SWIGTYPE_p_std__functionT_bool_flongF_t is_match) {
    SWIGTYPE_p_std__optionalT_long_t ret = new SWIGTYPE_p_std__optionalT_long_t(operations_research_constraint_solverPINVOKE.RoutingModel_GetFirstMatchingPickupDeliverySibling(swigCPtr, node, SWIGTYPE_p_std__functionT_bool_flongF_t.getCPtr(is_match)), true);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    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 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 SetPathEnergyCostOfVehicle(string force, string distance, long cost_per_unit, int vehicle) {
    operations_research_constraint_solverPINVOKE.RoutingModel_SetPathEnergyCostOfVehicle(swigCPtr, force, distance, cost_per_unit, vehicle);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public void SetPathEnergyCostsOfVehicle(string force, string distance, long threshold, long cost_per_unit_below_threshold, long cost_per_unit_above_threshold, int vehicle) {
    operations_research_constraint_solverPINVOKE.RoutingModel_SetPathEnergyCostsOfVehicle(swigCPtr, force, distance, threshold, cost_per_unit_below_threshold, cost_per_unit_above_threshold, vehicle);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
  }
 
  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 AddRouteConstraint(SWIGTYPE_p_std__functionT_std__optionalT_long_t_fstd__vectorT_int64_t_t_const_RF_t route_evaluator, bool costs_are_homogeneous_across_vehicles) {
    operations_research_constraint_solverPINVOKE.RoutingModel_AddRouteConstraint__SWIG_0(swigCPtr, SWIGTYPE_p_std__functionT_std__optionalT_long_t_fstd__vectorT_int64_t_t_const_RF_t.getCPtr(route_evaluator), costs_are_homogeneous_across_vehicles);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public void AddRouteConstraint(SWIGTYPE_p_std__functionT_std__optionalT_long_t_fstd__vectorT_int64_t_t_const_RF_t route_evaluator) {
    operations_research_constraint_solverPINVOKE.RoutingModel_AddRouteConstraint__SWIG_1(swigCPtr, SWIGTYPE_p_std__functionT_std__optionalT_long_t_fstd__vectorT_int64_t_t_const_RF_t.getCPtr(route_evaluator));
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public SWIGTYPE_p_std__optionalT_long_t GetRouteCost( long[]  route) {
    SWIGTYPE_p_std__optionalT_long_t ret = new SWIGTYPE_p_std__optionalT_long_t(operations_research_constraint_solverPINVOKE.RoutingModel_GetRouteCost(swigCPtr,  route.Length, route ), true);
    return ret;
  }
 
  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 SetFirstSolutionHint(Assignment hint) {
    operations_research_constraint_solverPINVOKE.RoutingModel_SetFirstSolutionHint(swigCPtr, Assignment.getCPtr(hint));
  }
 
  public Assignment GetFirstSolutionHint() {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_GetFirstSolutionHint(swigCPtr);
    Assignment ret = (cPtr == global::System.IntPtr.Zero) ? null : new Assignment(cPtr, false);
    return ret;
  }
 
  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 AddEnterSearchCallback( VoidToVoid  callback) {
    operations_research_constraint_solverPINVOKE.RoutingModel_AddEnterSearchCallback(swigCPtr,  StoreVoidToVoid(callback) );
  }
 
  public void AddAtSolutionCallback( VoidToVoid  callback, bool track_unchecked_neighbors) {
    operations_research_constraint_solverPINVOKE.RoutingModel_AddAtSolutionCallback__SWIG_0(swigCPtr,  StoreVoidToVoid(callback) , track_unchecked_neighbors);
  }
 
  public void AddAtSolutionCallback( VoidToVoid  callback) {
    operations_research_constraint_solverPINVOKE.RoutingModel_AddAtSolutionCallback__SWIG_1(swigCPtr,  StoreVoidToVoid(callback) );
  }
 
  public void AddRestoreDimensionValuesResetCallback( VoidToVoid  callback) {
    operations_research_constraint_solverPINVOKE.RoutingModel_AddRestoreDimensionValuesResetCallback(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 AddWeightedVariableMaximizedByFinalizer(IntVar var, long cost) {
    operations_research_constraint_solverPINVOKE.RoutingModel_AddWeightedVariableMaximizedByFinalizer(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 AddWeightedVariableTargetToFinalizer(IntVar var, long target, long cost) {
    operations_research_constraint_solverPINVOKE.RoutingModel_AddWeightedVariableTargetToFinalizer(swigCPtr, IntVar.getCPtr(var), target, cost);
  }
 
  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, ProtoHelper.ProtoToByteArray(search_parameters, out var buffer), buffer);
  }
 
  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, ProtoHelper.ProtoToByteArray(search_parameters, out var buffer), buffer);
    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), ProtoHelper.ProtoToByteArray(search_parameters, out var buffer), buffer);
    Assignment ret = (cPtr == global::System.IntPtr.Zero) ? null : new Assignment(cPtr, false);
    return ret;
  }
 
  public Assignment FastSolveFromAssignmentWithParameters(Assignment assignment, Google.OrTools.ConstraintSolver.RoutingSearchParameters search_parameters, bool check_solution_in_cp, SWIGTYPE_p_absl__flat_hash_setT_operations_research__IntVar_p_t touched) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_FastSolveFromAssignmentWithParameters__SWIG_0(swigCPtr, Assignment.getCPtr(assignment), ProtoHelper.ProtoToByteArray(search_parameters, out var buffer), buffer, check_solution_in_cp, SWIGTYPE_p_absl__flat_hash_setT_operations_research__IntVar_p_t.getCPtr(touched));
    Assignment ret = (cPtr == global::System.IntPtr.Zero) ? null : new Assignment(cPtr, false);
    return ret;
  }
 
  public Assignment FastSolveFromAssignmentWithParameters(Assignment assignment, Google.OrTools.ConstraintSolver.RoutingSearchParameters search_parameters, bool check_solution_in_cp) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_FastSolveFromAssignmentWithParameters__SWIG_1(swigCPtr, Assignment.getCPtr(assignment), ProtoHelper.ProtoToByteArray(search_parameters, out var buffer), buffer, check_solution_in_cp);
    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), ProtoHelper.ProtoToByteArray(search_parameters, out var buffer), buffer, 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), ProtoHelper.ProtoToByteArray(search_parameters, out var buffer), buffer);
    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 SolveWithIteratedLocalSearch(Google.OrTools.ConstraintSolver.RoutingSearchParameters search_parameters) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_SolveWithIteratedLocalSearch(swigCPtr, ProtoHelper.ProtoToByteArray(search_parameters, out var buffer), buffer);
    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 long ObjectiveLowerBound() {
    long ret = operations_research_constraint_solverPINVOKE.RoutingModel_ObjectiveLowerBound(swigCPtr);
    return ret;
  }
 
  public Google.OrTools.ConstraintSolver.RoutingSearchStatus.Types.Value GetStatus() {
  return (Google.OrTools.ConstraintSolver.RoutingSearchStatus.Types.Value) operations_research_constraint_solverPINVOKE.RoutingModel_GetStatus(swigCPtr);
}
 
  public bool EnableDeepSerialization() {
    bool ret = operations_research_constraint_solverPINVOKE.RoutingModel_EnableDeepSerialization(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 partial class NodeNeighborsParameters : global::System.IDisposable {
    private global::System.Runtime.InteropServices.HandleRef swigCPtr;
    protected bool swigCMemOwn;
  
    internal NodeNeighborsParameters(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(NodeNeighborsParameters obj) {
      return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
    }
  
    internal static global::System.Runtime.InteropServices.HandleRef swigRelease(NodeNeighborsParameters obj) {
      if (obj != null) {
        if (!obj.swigCMemOwn)
          throw new global::System.ApplicationException("Cannot release ownership as memory is not owned");
        global::System.Runtime.InteropServices.HandleRef ptr = obj.swigCPtr;
        obj.swigCMemOwn = false;
        obj.Dispose();
        return ptr;
      } else {
        return new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
      }
    }
  
    ~NodeNeighborsParameters() {
      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_NodeNeighborsParameters(swigCPtr);
          }
          swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
        }
      }
    }
  
    public int num_neighbors {
      set {
        operations_research_constraint_solverPINVOKE.RoutingModel_NodeNeighborsParameters_num_neighbors_set(swigCPtr, value);
      } 
      get {
        int ret = operations_research_constraint_solverPINVOKE.RoutingModel_NodeNeighborsParameters_num_neighbors_get(swigCPtr);
        return ret;
      } 
    }
  
    public bool add_vehicle_starts_to_neighbors {
      set {
        operations_research_constraint_solverPINVOKE.RoutingModel_NodeNeighborsParameters_add_vehicle_starts_to_neighbors_set(swigCPtr, value);
      } 
      get {
        bool ret = operations_research_constraint_solverPINVOKE.RoutingModel_NodeNeighborsParameters_add_vehicle_starts_to_neighbors_get(swigCPtr);
        return ret;
      } 
    }
  
    public bool add_vehicle_ends_to_neighbors {
      set {
        operations_research_constraint_solverPINVOKE.RoutingModel_NodeNeighborsParameters_add_vehicle_ends_to_neighbors_set(swigCPtr, value);
      } 
      get {
        bool ret = operations_research_constraint_solverPINVOKE.RoutingModel_NodeNeighborsParameters_add_vehicle_ends_to_neighbors_get(swigCPtr);
        return ret;
      } 
    }
  
    public bool only_sort_neighbors_for_partial_neighborhoods {
      set {
        operations_research_constraint_solverPINVOKE.RoutingModel_NodeNeighborsParameters_only_sort_neighbors_for_partial_neighborhoods_set(swigCPtr, value);
      } 
      get {
        bool ret = operations_research_constraint_solverPINVOKE.RoutingModel_NodeNeighborsParameters_only_sort_neighbors_for_partial_neighborhoods_get(swigCPtr);
        return ret;
      } 
    }
  
    public NodeNeighborsParameters() : this(operations_research_constraint_solverPINVOKE.new_RoutingModel_NodeNeighborsParameters(), true) {
    }
  
  }
 
  public partial class NodeNeighborsByCostClass : global::System.IDisposable {
    private global::System.Runtime.InteropServices.HandleRef swigCPtr;
    protected bool swigCMemOwn;
  
    internal NodeNeighborsByCostClass(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(NodeNeighborsByCostClass obj) {
      return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
    }
  
    internal static global::System.Runtime.InteropServices.HandleRef swigRelease(NodeNeighborsByCostClass obj) {
      if (obj != null) {
        if (!obj.swigCMemOwn)
          throw new global::System.ApplicationException("Cannot release ownership as memory is not owned");
        global::System.Runtime.InteropServices.HandleRef ptr = obj.swigCPtr;
        obj.swigCMemOwn = false;
        obj.Dispose();
        return ptr;
      } else {
        return new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
      }
    }
  
    ~NodeNeighborsByCostClass() {
      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_NodeNeighborsByCostClass(swigCPtr);
          }
          swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
        }
      }
    }
  
    public NodeNeighborsByCostClass(RoutingModel routing_model) : this(operations_research_constraint_solverPINVOKE.new_RoutingModel_NodeNeighborsByCostClass(RoutingModel.getCPtr(routing_model)), true) {
    }
  
    public void ComputeNeighbors(RoutingModel.NodeNeighborsParameters params_) {
      operations_research_constraint_solverPINVOKE.RoutingModel_NodeNeighborsByCostClass_ComputeNeighbors(swigCPtr, RoutingModel.NodeNeighborsParameters.getCPtr(params_));
      if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    }
  
    public  int[]  GetIncomingNeighborsOfNodeForCostClass(int cost_class, int node_index) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_NodeNeighborsByCostClass_GetIncomingNeighborsOfNodeForCostClass(swigCPtr, cost_class, node_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  int[]  GetOutgoingNeighborsOfNodeForCostClass(int cost_class, int node_index) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_NodeNeighborsByCostClass_GetOutgoingNeighborsOfNodeForCostClass(swigCPtr, cost_class, node_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 bool IsNeighborhoodArcForCostClass(int cost_class, long from, long to) {
      bool ret = operations_research_constraint_solverPINVOKE.RoutingModel_NodeNeighborsByCostClass_IsNeighborhoodArcForCostClass(swigCPtr, cost_class, from, to);
      return ret;
    }
  
  }
 
  public RoutingModel.NodeNeighborsByCostClass GetOrCreateNodeNeighborsByCostClass(double neighbors_ratio, long min_neighbors, SWIGTYPE_p_double neighbors_ratio_used, bool add_vehicle_starts_to_neighbors, bool add_vehicle_ends_to_neighbors, bool only_sort_neighbors_for_partial_neighborhoods) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_GetOrCreateNodeNeighborsByCostClass__SWIG_0(swigCPtr, neighbors_ratio, min_neighbors, SWIGTYPE_p_double.getCPtr(neighbors_ratio_used), add_vehicle_starts_to_neighbors, add_vehicle_ends_to_neighbors, only_sort_neighbors_for_partial_neighborhoods);
    RoutingModel.NodeNeighborsByCostClass ret = (cPtr == global::System.IntPtr.Zero) ? null : new RoutingModel.NodeNeighborsByCostClass(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public RoutingModel.NodeNeighborsByCostClass GetOrCreateNodeNeighborsByCostClass(double neighbors_ratio, long min_neighbors, SWIGTYPE_p_double neighbors_ratio_used, bool add_vehicle_starts_to_neighbors, bool add_vehicle_ends_to_neighbors) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_GetOrCreateNodeNeighborsByCostClass__SWIG_1(swigCPtr, neighbors_ratio, min_neighbors, SWIGTYPE_p_double.getCPtr(neighbors_ratio_used), add_vehicle_starts_to_neighbors, add_vehicle_ends_to_neighbors);
    RoutingModel.NodeNeighborsByCostClass ret = (cPtr == global::System.IntPtr.Zero) ? null : new RoutingModel.NodeNeighborsByCostClass(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public RoutingModel.NodeNeighborsByCostClass GetOrCreateNodeNeighborsByCostClass(double neighbors_ratio, long min_neighbors, SWIGTYPE_p_double neighbors_ratio_used, bool add_vehicle_starts_to_neighbors) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_GetOrCreateNodeNeighborsByCostClass__SWIG_2(swigCPtr, neighbors_ratio, min_neighbors, SWIGTYPE_p_double.getCPtr(neighbors_ratio_used), add_vehicle_starts_to_neighbors);
    RoutingModel.NodeNeighborsByCostClass ret = (cPtr == global::System.IntPtr.Zero) ? null : new RoutingModel.NodeNeighborsByCostClass(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public RoutingModel.NodeNeighborsByCostClass GetOrCreateNodeNeighborsByCostClass(double neighbors_ratio, long min_neighbors, SWIGTYPE_p_double neighbors_ratio_used) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_GetOrCreateNodeNeighborsByCostClass__SWIG_3(swigCPtr, neighbors_ratio, min_neighbors, SWIGTYPE_p_double.getCPtr(neighbors_ratio_used));
    RoutingModel.NodeNeighborsByCostClass ret = (cPtr == global::System.IntPtr.Zero) ? null : new RoutingModel.NodeNeighborsByCostClass(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public RoutingModel.NodeNeighborsByCostClass GetOrCreateNodeNeighborsByCostClass(RoutingModel.NodeNeighborsParameters params_) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_GetOrCreateNodeNeighborsByCostClass__SWIG_4(swigCPtr, RoutingModel.NodeNeighborsParameters.getCPtr(params_));
    RoutingModel.NodeNeighborsByCostClass ret = (cPtr == global::System.IntPtr.Zero) ? null : new RoutingModel.NodeNeighborsByCostClass(cPtr, false);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  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  int[]  GetSameActivityIndicesOfIndex(int node) {
  global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_GetSameActivityIndicesOfIndex(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 int GetSameActivityGroupOfIndex(int node) {
    int ret = operations_research_constraint_solverPINVOKE.RoutingModel_GetSameActivityGroupOfIndex(swigCPtr, node);
    return ret;
  }
 
  public int GetSameActivityGroupsCount() {
    int ret = operations_research_constraint_solverPINVOKE.RoutingModel_GetSameActivityGroupsCount(swigCPtr);
    return ret;
  }
 
  public  int[]  GetSameActivityIndicesOfGroup(int group) {
  global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_GetSameActivityIndicesOfGroup(swigCPtr, group);
  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 bool CheckIfAssignmentIsFeasible(Assignment assignment, bool call_at_solution_monitors) {
    bool ret = operations_research_constraint_solverPINVOKE.RoutingModel_CheckIfAssignmentIsFeasible(swigCPtr, Assignment.getCPtr(assignment), call_at_solution_monitors);
    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(SWIGTYPE_p_absl__Duration offset) {
    bool ret = operations_research_constraint_solverPINVOKE.RoutingModel_CheckLimit__SWIG_0(swigCPtr, SWIGTYPE_p_absl__Duration.getCPtr(offset));
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public bool CheckLimit() {
    bool ret = operations_research_constraint_solverPINVOKE.RoutingModel_CheckLimit__SWIG_1(swigCPtr);
    return ret;
  }
 
  public void UpdateTimeLimit(SWIGTYPE_p_absl__Duration time_limit) {
    operations_research_constraint_solverPINVOKE.RoutingModel_UpdateTimeLimit(swigCPtr, SWIGTYPE_p_absl__Duration.getCPtr(time_limit));
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public SWIGTYPE_p_absl__Duration TimeBuffer() {
    SWIGTYPE_p_absl__Duration ret = new SWIGTYPE_p_absl__Duration(operations_research_constraint_solverPINVOKE.RoutingModel_TimeBuffer(swigCPtr), true);
    return ret;
  }
 
  public SWIGTYPE_p_std__atomicT_bool_t GetMutableCPSatInterrupt() {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_GetMutableCPSatInterrupt(swigCPtr);
    SWIGTYPE_p_std__atomicT_bool_t ret = (cPtr == global::System.IntPtr.Zero) ? null : new SWIGTYPE_p_std__atomicT_bool_t(cPtr, false);
    return ret;
  }
 
  public SWIGTYPE_p_std__atomicT_bool_t GetMutableCPInterrupt() {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.RoutingModel_GetMutableCPInterrupt(swigCPtr);
    SWIGTYPE_p_std__atomicT_bool_t ret = (cPtr == global::System.IntPtr.Zero) ? null : new SWIGTYPE_p_std__atomicT_bool_t(cPtr, false);
    return ret;
  }
 
  public void CancelSearch() {
    operations_research_constraint_solverPINVOKE.RoutingModel_CancelSearch(swigCPtr);
  }
 
  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, ProtoHelper.ProtoToByteArray(search_parameters, out var buffer), buffer);
    return ret;
  }
 
  public long GetNumberOfRejectsInFirstSolution(Google.OrTools.ConstraintSolver.RoutingSearchParameters search_parameters) {
    long ret = operations_research_constraint_solverPINVOKE.RoutingModel_GetNumberOfRejectsInFirstSolution(swigCPtr, ProtoHelper.ProtoToByteArray(search_parameters, out var buffer), buffer);
    return ret;
  }
 
  public bool IsMatchingModel() {
    bool ret = operations_research_constraint_solverPINVOKE.RoutingModel_IsMatchingModel(swigCPtr);
    return ret;
  }
 
  public bool AreRoutesInterdependent(SWIGTYPE_p_operations_research__RoutingSearchParameters parameters) {
    bool ret = operations_research_constraint_solverPINVOKE.RoutingModel_AreRoutesInterdependent(swigCPtr, SWIGTYPE_p_operations_research__RoutingSearchParameters.getCPtr(parameters));
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
    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;
  }
 
  public PathsMetadata GetPathsMetadata() {
    PathsMetadata ret = new PathsMetadata(operations_research_constraint_solverPINVOKE.RoutingModel_GetPathsMetadata(swigCPtr), false);
    return ret;
  }
 
  public SWIGTYPE_p_std__dequeT_int_t GetVehiclesOfSameClass(long start_end_index) {
    SWIGTYPE_p_std__dequeT_int_t ret = new SWIGTYPE_p_std__dequeT_int_t(operations_research_constraint_solverPINVOKE.RoutingModel_GetVehiclesOfSameClass(swigCPtr, start_end_index), false);
    return ret;
  }
 
  public SWIGTYPE_p_std__vectorT_std__pairT_long_long_t_t GetSameVehicleClassArcs(long from_index, long to_index) {
    SWIGTYPE_p_std__vectorT_std__pairT_long_long_t_t ret = new SWIGTYPE_p_std__vectorT_std__pairT_long_long_t_t(operations_research_constraint_solverPINVOKE.RoutingModel_GetSameVehicleClassArcs(swigCPtr, from_index, to_index), true);
    return ret;
  }
 
  // 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();
 
  // TransitEvaluatorSign 
  public static readonly int kTransitEvaluatorSignUnknown = operations_research_constraint_solverPINVOKE.RoutingModel_kTransitEvaluatorSignUnknown_get();
  public static readonly int kTransitEvaluatorSignPositiveOrZero = operations_research_constraint_solverPINVOKE.RoutingModel_kTransitEvaluatorSignPositiveOrZero_get();
  public static readonly int kTransitEvaluatorSignNegativeOrZero = operations_research_constraint_solverPINVOKE.RoutingModel_kTransitEvaluatorSignNegativeOrZero_get();
 
  // PenaltyCostBehavior 
  public static readonly int PENALIZE_ONCE = operations_research_constraint_solverPINVOKE.RoutingModel_PENALIZE_ONCE_get();
  public static readonly int PENALIZE_PER_INACTIVE = operations_research_constraint_solverPINVOKE.RoutingModel_PENALIZE_PER_INACTIVE_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();
 
}
 
}