diff --git a/.gitignore b/.gitignore index b956c13..2e952a8 100644 --- a/.gitignore +++ b/.gitignore @@ -2,4 +2,12 @@ *.class *.jar obj/* -lib/* \ No newline at end of file +lib/* +build/* + +# general file ignore pattern for test outputs +*.ign.* + +# idea files +.idea/ +jscipopt.iml diff --git a/CMakeLists.txt b/CMakeLists.txt index df4966f..113af67 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -34,6 +34,7 @@ set(SWIG_JAVA_SOURCES ${PROJECT_SOURCE_DIR}/java/jscip/SCIP_VerbLevel.java ${PROJECT_SOURCE_DIR}/java/jscip/SCIP_Status.java ${PROJECT_SOURCE_DIR}/java/jscip/SCIP_Stage.java + ${PROJECT_SOURCE_DIR}/java/jscip/SCIP_Result.java ${PROJECT_SOURCE_DIR}/java/jscip/SWIGTYPE_p_char.java ${PROJECT_SOURCE_DIR}/java/jscip/SWIGTYPE_p_double.java ${PROJECT_SOURCE_DIR}/java/jscip/SWIGTYPE_p_int.java @@ -55,6 +56,46 @@ set(SWIG_JAVA_SOURCES ${PROJECT_SOURCE_DIR}/java/jscip/SWIGTYPE_p_SCIP_EXPR.java ${PROJECT_SOURCE_DIR}/java/jscip/SWIGTYPE_p_SCIP_HEUR.java ${PROJECT_SOURCE_DIR}/java/jscip/SWIGTYPE_p_SCIP_Messagehdlr.java + ${PROJECT_SOURCE_DIR}/java/jscip/ObjEventhdlr.java + ${PROJECT_SOURCE_DIR}/java/jscip/SWIGTYPE_p_SCIP_EVENT.java + ${PROJECT_SOURCE_DIR}/java/jscip/SWIGTYPE_p_p_SCIP_EVENTDATA.java + ${PROJECT_SOURCE_DIR}/java/jscip/SWIGTYPE_p_SCIP_EVENTDATA.java + ${PROJECT_SOURCE_DIR}/java/jscip/SWIGTYPE_p_SCIP_EVENTHDLR.java + ${PROJECT_SOURCE_DIR}/java/jscip/SWIGTYPE_p_SCIP_Eventhdlr.java + ${PROJECT_SOURCE_DIR}/java/jscip/SWIGTYPE_p_SCIP_EVENTTYPE.java + ${PROJECT_SOURCE_DIR}/java/jscip/SWIGTYPE_p_uint64_t.java + ${PROJECT_SOURCE_DIR}/java/jscip/SCIP_Event.java + ${PROJECT_SOURCE_DIR}/java/jscip/SCIP_EventVarAdded.java + ${PROJECT_SOURCE_DIR}/java/jscip/SCIP_EventVarDeleted.java + ${PROJECT_SOURCE_DIR}/java/jscip/SCIP_EventVarFixed.java + ${PROJECT_SOURCE_DIR}/java/jscip/SCIP_EventVarUnlocked.java + ${PROJECT_SOURCE_DIR}/java/jscip/SCIP_EventObjChg.java + ${PROJECT_SOURCE_DIR}/java/jscip/SCIP_EventBdChg.java + ${PROJECT_SOURCE_DIR}/java/jscip/SCIP_EventHole.java + ${PROJECT_SOURCE_DIR}/java/jscip/SCIP_EventImplAdd.java + ${PROJECT_SOURCE_DIR}/java/jscip/SCIP_EventTypeChg.java + ${PROJECT_SOURCE_DIR}/java/jscip/SCIP_EventRowAddedSepa.java + ${PROJECT_SOURCE_DIR}/java/jscip/SCIP_EventRowDeletedSepa.java + ${PROJECT_SOURCE_DIR}/java/jscip/SCIP_EventRowAddedLP.java + ${PROJECT_SOURCE_DIR}/java/jscip/SCIP_EventRowDeletedLP.java + ${PROJECT_SOURCE_DIR}/java/jscip/SCIP_EventRowCoefChanged.java + ${PROJECT_SOURCE_DIR}/java/jscip/SCIP_EventRowConstChanged.java + ${PROJECT_SOURCE_DIR}/java/jscip/SCIP_EventRowSideChanged.java + ${PROJECT_SOURCE_DIR}/java/jscip/SWIGTYPE_p_SCIP_COL.java + ${PROJECT_SOURCE_DIR}/java/jscip/SWIGTYPE_p_SCIP_ROW.java + ${PROJECT_SOURCE_DIR}/java/jscip/SWIGTYPE_p_SCIP_NODE.java + ${PROJECT_SOURCE_DIR}/java/jscip/SWIGTYPE_p_SCIP_SIDETYPE.java + ${PROJECT_SOURCE_DIR}/java/jscip/ObjConshdlr.java + ${PROJECT_SOURCE_DIR}/java/jscip/SWIGTYPE_p_p_SCIP_CONSDATA.java + ${PROJECT_SOURCE_DIR}/java/jscip/SWIGTYPE_p_SCIP_BDCHGIDX.java + ${PROJECT_SOURCE_DIR}/java/jscip/SWIGTYPE_p_SCIP_CONSHDLR.java + ${PROJECT_SOURCE_DIR}/java/jscip/SWIGTYPE_p_SCIP_DIVESET.java + ${PROJECT_SOURCE_DIR}/java/jscip/SWIGTYPE_p_SCIP_HASHMAP.java + ${PROJECT_SOURCE_DIR}/java/jscip/SCIP_LockType.java + ${PROJECT_SOURCE_DIR}/java/jscip/SWIGTYPE_p_SCIP_PRESOLTIMING.java + ${PROJECT_SOURCE_DIR}/java/jscip/SWIGTYPE_p_SCIP_PROPTIMING.java + ${PROJECT_SOURCE_DIR}/java/jscip/SWIGTYPE_p_SCIP_Result.java + ${PROJECT_SOURCE_DIR}/java/jscip/SWIGTYPE_p_SYM_GRAPH.java ) set(JAVA_SOURCES @@ -66,6 +107,13 @@ set(JAVA_SOURCES ${PROJECT_SOURCE_DIR}/java/jscip/Constraint.java ${PROJECT_SOURCE_DIR}/java/jscip/Solution.java ${PROJECT_SOURCE_DIR}/java/jscip/MessageHandler.java + ${PROJECT_SOURCE_DIR}/java/jscip/EventHandler.java + ${PROJECT_SOURCE_DIR}/java/jscip/EventType.java + ${PROJECT_SOURCE_DIR}/java/jscip/ResultHolder.java + ${PROJECT_SOURCE_DIR}/java/jscip/ConstraintHandler.java + ${PROJECT_SOURCE_DIR}/java/jscip/ScipPresolTiming.java + ${PROJECT_SOURCE_DIR}/java/jscip/ScipPropTiming.java + ${PROJECT_SOURCE_DIR}/java/jscip/IntHolder.java ) # diff --git a/examples/PortfolioOptimization.java b/examples/PortfolioOptimization.java new file mode 100644 index 0000000..c294b7c --- /dev/null +++ b/examples/PortfolioOptimization.java @@ -0,0 +1,413 @@ +import jscip.*; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.Random; + +/** + * Illustrating the use of ObjEventHandler to implement a custom stopping criterion. + */ +public class PortfolioOptimization { + + public static void main(String[] args) { + System.loadLibrary("jscip"); + if (args.length == 1 && args[0].equals("--help")) { + System.out.println("Usage: PortfolioOptimization "); + return; + } + int assetCount = 35; + if (args.length >= 1) { + assetCount = Integer.parseInt(args[0]); + } + int maxPositionCount = 12; + if (args.length >= 2) { + maxPositionCount = Integer.parseInt(args[1]); + } + double minPositionWeight = 0.01; + if (args.length >= 3) { + minPositionWeight = Double.parseDouble(args[2]); + } + double maxPositionWeight = 0.2; + if (args.length >= 4) { + maxPositionWeight = Double.parseDouble(args[3]); + } + double riskAffinity = 0.1; + if (args.length >= 5) { + riskAffinity = Double.parseDouble(args[4]); + } + long rngSeed = 0; + if (args.length >= 6) { + rngSeed = args[5].hashCode(); + } + + // random generate input data, however assets with higher returns should have generally higher risk + Random rng = new Random(rngSeed); + double oneOverAssetCount = 1.0 / (assetCount - 1); + + double[] returns = new double[assetCount]; + for (int i = 0; i != assetCount; ++i) { + returns[i] = 0.005 + 0.1 * oneOverAssetCount * (i - 0.2 + rng.nextDouble() * 0.4); + } + + // create covariance matrix + double[][] covarianceMatrix = new double[assetCount][]; + double[] assetVariances = new double[assetCount]; + for (int i = 0; i != assetCount; ++i) { + assetVariances[i] = returns[i] * returns[i] * 20; + } + for (int i = 0; i != assetCount; ++i) { + double[] row = covarianceMatrix[i] = new double[assetCount]; + double assetVarianceI = assetVariances[i]; + for (int j = 0; j <= i; ++j) { + double covariance; + if (i == j) { + covariance = assetVarianceI * assetVariances[j] // correlation is 1 on the diagonal by definition + + (0.003 + rng.nextDouble() * 0.0015); // some intrinsic risk on the diagonal + } else { + // random correlation + covariance = rng.nextDouble() * assetVarianceI * assetVariances[j]; + } + row[j] = covariance; + } + } + // copying lower triangle of the matrix into the upper triangle + for (int i = 0; i != assetCount; ++i) { + for (int j = 0; j < i; ++j) { + covarianceMatrix[j][i] = covarianceMatrix[i][j]; + } + } + + Scip scip = new Scip(); + scip.create("Portfolio Optimization"); + // The debugger crashes the program because it tries to access Constraint::getName, if the constraint is + // released too early. So I add them all into a list and only release everything at the end. + List variables = new ArrayList<>(); + List constraints = new ArrayList<>(); + + // create portfolio weight variables + Variable[] positionVariables = new Variable[assetCount]; + for (int i = 0; i != assetCount; ++i) { + variables.add( + positionVariables[i] = scip.createVar( + "position_" + i, + 0.0, + maxPositionWeight, + 0.0, + SCIP_Vartype.SCIP_VARTYPE_CONTINUOUS + ) + ); + } + // create binary positive indicator variables + Variable[] positiveIndicators = new Variable[assetCount]; + for (int i = 0; i != assetCount; ++i) { + variables.add( + positiveIndicators[i] = scip.createVar( + "posInd_" + i, + 0.0, + 1.0, + 0.0, + SCIP_Vartype.SCIP_VARTYPE_BINARY + ) + ); + } + // linking position variables with positive indicator variables + for (int i = 0; i != assetCount; ++i) { + // w_i - b_i <= 0 + Constraint cons = scip.createConsLinear( + "posIndLink_" + i, + new Variable[]{positionVariables[i], positiveIndicators[i]}, + new double[]{1.0, -1.0}, + -scip.infinity(), + 0.0 + ); + constraints.add(cons); + scip.addCons(cons); + } + if (minPositionWeight > 0.0) { + // create minimum weight constraints. Skipping the first asset assuming it's a liquidity account. + for (int i = 1; i != assetCount; ++i) { + // w_i - minPos * b_i >= 0 + Constraint cons = scip.createConsLinear( + "minWeight_" + i, + new Variable[]{positionVariables[i], positiveIndicators[i]}, + new double[]{1.0, -minPositionWeight}, + 0.0, + scip.infinity() + ); + scip.addCons(cons); + constraints.add(cons); + } + } + + // budget constraint: sum of all positions must be equal to 1 + double[] arrayOfOnes = new double[assetCount]; + Arrays.fill(arrayOfOnes, 1.0); + Constraint budget = scip.createConsLinear( + "budget", + positionVariables, + arrayOfOnes, + 1.0, + 1.0 + ); + scip.addCons(budget); + constraints.add(budget); + + if (maxPositionCount > 0) { + // max position count constraint, #(positions > 0) <= maxPositionCount + Constraint positionCountConstraint = scip.createConsLinear( + "maxPositionCount", + positiveIndicators, + arrayOfOnes, + 0.0, + maxPositionCount + ); + scip.addCons(positionCountConstraint); + constraints.add(positionCountConstraint); + } + + Variable objVar = scip.createVar( + "objVar", + -scip.infinity(), + scip.infinity(), + 1.0, + SCIP_Vartype.SCIP_VARTYPE_CONTINUOUS + ); + variables.add(objVar); + + // create objective constraint and link it to objVar1 + // maximize returns while also avoiding unnecessary risk. The proportionality factor between risk and return + // is expressed through riskAffinity parameter. Higher riskAffinity means the user cares more about maximizing + // his returns and less about avoiding risk: + // max( + // - 1 / (2 * riskAffinity) * positionWeights^T * covarianceMatrix * positionWeights + // + returns * positionWeights + // ) + // Since objVar is minimized by Scip, we need to create the constraint times -1: + // 1 / (2 * riskAffinity) * positionWeights^T * covarianceMatrix * positionWeights + // - returns * positionWeights + // - objVar <= 0 + + // quadratic objective terms + int quadObjectiveTermCount = assetCount * (assetCount + 1) / 2; // one triangle of the matrix plus its diagonal + Variable[] quadVars1 = new Variable[quadObjectiveTermCount]; + Variable[] quadVars2 = new Variable[quadObjectiveTermCount]; + double[] quadCoeffs = new double[quadObjectiveTermCount]; + int quadIdx = 0; + for (int i = 0; i != assetCount; ++i) { + for (int j = 0; j <= i; ++j) { + quadVars1[quadIdx] = positionVariables[i]; + quadVars2[quadIdx] = positionVariables[j]; + quadCoeffs[quadIdx] = covarianceMatrix[i][j] / riskAffinity; // division by 2 disappears, because we + // would also need to add covarianceMatrix[j][i] but it's symmetric by construction + ++quadIdx; + } + } + // linear objective terms + Variable[] linVars = new Variable[assetCount + 1]; // number of positions plus objective variable + double[] linCoeffs = new double[assetCount + 1]; + for (int i = 0; i != assetCount; ++i) { + linCoeffs[i] = -returns[i]; + linVars[i] = positionVariables[i]; + } + linCoeffs[assetCount] = -1; + linVars[assetCount] = objVar; + // objective constraint + Constraint objectiveConstraint = scip.createConsQuadratic( + "objectiveConstraint", + quadVars1, + quadVars2, + quadCoeffs, + linVars, + linCoeffs, + -scip.infinity(), + 0.0 + ); + scip.addCons(objectiveConstraint); + constraints.add(objectiveConstraint); + + // adding event handler with custom stopping criteria and solve + scip.addEventHandler( + new CustomStoppingCriterion( + positionVariables, + returns, + covarianceMatrix + ) + ); + scip.solve(); + + // print result + Solution solution = scip.getBestSol(); + double[] portfolioWeights = new double[assetCount]; + double[] indicatorValues = new double[assetCount]; + for (int i = 0; i != assetCount; ++i) { + portfolioWeights[i] = scip.getSolVal(solution, positionVariables[i]); + indicatorValues[i] = scip.getSolVal(solution, positiveIndicators[i]); + } + + for (int i = 0; i != assetCount; ++i) { + double weight = portfolioWeights[i]; + double assetReturn = returns[i]; + if (weight > 0.0) { + System.out.printf( + "Position %3d: %15.10f (pos indicator: %10.3f, return: %8.5f)%n", + i, + weight, + indicatorValues[i], + assetReturn + ); + } + } + System.out.format("%n%20s | %15s | %15s%n", "Portfolio", "expectedReturn", "variance"); + System.out.println("======================================================="); + String format = "%20s | %15.10f | %15.10f%n"; + System.out.format( + format, + "Best Solution", + dot(returns, portfolioWeights), + calculateVariance(covarianceMatrix, portfolioWeights) + ); + double[] equalPortfolio = new double[assetCount]; + for (int i = 0; i != assetCount; ++i) { + equalPortfolio[i] = 1.0 / assetCount; + } + System.out.format( + format, + "Equally distributed", + dot(returns, equalPortfolio), + calculateVariance(covarianceMatrix, equalPortfolio) + ); + for (int i = 0; i != assetCount; ++i) { + double[] singleAssetPortfolio = unitVector(assetCount, i); + System.out.format( + format, + "SingleAsset " + i + " Pf", + dot(returns, singleAssetPortfolio), + calculateVariance(covarianceMatrix, singleAssetPortfolio) + ); + } + + for (Variable variable : variables) { + scip.releaseVar(variable); + } + for (Constraint constraint : constraints) { + scip.releaseCons(constraint); + } + scip.free(); + } + + private static double[] readSolution(Scip scip, Solution solution, Variable[] variables) { + double[] solVector = new double[variables.length]; + for (int i = 0; i != variables.length; ++i) { + solVector[i] = scip.getSolVal(solution, variables[i]); + } + return solVector; + } + + private static double calculateVariance(double[][] covariance, double[] portfolio) { + double variance = 0.0; + for (int i = 0; i != portfolio.length; ++i) { + double weightI = portfolio[i]; + double[] covRow = covariance[i]; + if (weightI > 0) { + for (int j = 0; j != portfolio.length; ++j) { + variance += covRow[j] * weightI * portfolio[j]; + } + } + } + return variance; + } + + public static double dot(double[] a, double[] b) { + double sum = 0.0; + assert a.length == b.length : "Vectors must be of equal length."; + for (int i = 0; i != a.length; ++i) { + sum += a[i] * b[i]; + } + return sum; + } + + public static double[] unitVector(int size, int unitIndex) { + double[] result = new double[size]; + result[unitIndex] = 1.0; + return result; + } + + public static class CustomStoppingCriterion extends EventHandler { + + private final Variable[] positionVariables; + private final double[] returns; + private final double[][] covarianceMatrix; + private final long started = System.currentTimeMillis(); + private double lastObjValue; + private int solutionCount = 0; + private long lastExecution = started; + + public CustomStoppingCriterion( + Variable[] positionVariables, + double[] returns, + double[][] covarianceMatrix + ) { + super("SolutionObserver", "Implements custom stopping criterion.", EventType.BESTSOLFOUND); + this.positionVariables = positionVariables; + this.returns = returns; + this.covarianceMatrix = covarianceMatrix; + } + + @Override + protected SCIP_Retcode scipExec(Scip scip, SCIP_Event event) { + assert (event.getEventtype() & EventType.BESTSOLFOUND) != 0 : "Unexpected event caught"; + Solution solution = new Solution(SCIPJNI.getEventDataSolution(event)); + if (scip.isSolveInterrupted()) { + System.out.println("Already interrupted. Skipping execution."); + return SCIP_Retcode.SCIP_OKAY; + } + ElapsedSeconds elapsed = elapsedSeconds(); + double currentObjValue = scip.getSolOrigObj(solution); + { // debug output + double[] solVec = readSolution(scip, solution, positionVariables); + double variance = calculateVariance(covarianceMatrix, solVec); + double expReturn = dot(solVec, returns); + System.out.println( + "Got solution " + solutionCount + ", return: " + expReturn + ", variance: " + variance + ); + } + if (solutionCount > 0) { + double currentGap = scip.getGap(); + if (currentGap < 0.05) { + double temporalGap = Math.abs(lastObjValue - currentObjValue) + / Math.max(lastObjValue, currentObjValue); + if (temporalGap < 1.0e-4 && elapsed.sinceStart > 5.0) { + System.out.println("Objective value improvement below limit. Interrupting."); + scip.interruptSolve(); + } + } + } + ++solutionCount; + lastObjValue = currentObjValue; + return SCIP_Retcode.SCIP_OKAY; + } + + private ElapsedSeconds elapsedSeconds() { + long currentMillis = System.currentTimeMillis(); + ElapsedSeconds result = new ElapsedSeconds( + (currentMillis - started) / 1000.0, + (currentMillis - lastExecution) / 1000.0 + ); + lastExecution = currentMillis; + return result; + } + + } + + private static class ElapsedSeconds { + private final double sinceStart; + private final double sincePreviousExecution; + + private ElapsedSeconds(double sinceStart, double sincePreviousExecution) { + this.sinceStart = sinceStart; + this.sincePreviousExecution = sincePreviousExecution; + } + } + +} diff --git a/examples/Tsp.java b/examples/Tsp.java new file mode 100644 index 0000000..92dd672 --- /dev/null +++ b/examples/Tsp.java @@ -0,0 +1,470 @@ +import jscip.*; + +import javax.imageio.ImageIO; +import java.awt.*; +import java.awt.image.BufferedImage; +import java.io.File; +import java.io.IOException; +import java.util.*; +import java.util.List; +import java.util.stream.Collectors; + +public class Tsp { + + private static final long DEFAULT_SEED = 4L; + + public static void main(String[] args) { + if (args.length == 1 && args[0].equals("--help")) { + System.out.println("Usage: Tsp [nodeCount] [outputImage] [seed]"); + return; + } + int nodeCount; + if (args.length >= 1) { + nodeCount = Integer.parseInt(args[0]); + } else { + nodeCount = 10; + } + String outputImage; + if (args.length >= 2) { + outputImage = args[1]; + } else { + outputImage = "tsp-iteration-%d.ign.png"; + } + long seed; + if (args.length >= 3) { + seed = args[2].hashCode(); + } else { + seed = DEFAULT_SEED; + } + Random rng = new Random(seed); + + // first create some random nodes in a 400 x 400 rectangle + List nodes = new ArrayList<>(); + for (int i = 0; i != nodeCount; ++i) { + nodes.add( + new Node( + i, + rng.nextInt(400), + rng.nextInt(400) + ) + ); + } + + System.loadLibrary("jscip"); + Scip scip = new Scip(); + scip.create("tsp"); + // contains the list of edges connected to the ith node + Map> edgesGroupedByNodes = new HashMap<>(); + List edges = new ArrayList<>(); + for (int i = 0; i != nodes.size(); ++i) { + Node left = nodes.get(i); + for (int j = 0; j != i; ++j) { + Node right = nodes.get(j); + Variable edgeVar = scip.createVar( + "edge_" + i + "_" + j, + 0.0, + 1.0, + left.dist(right), + SCIP_Vartype.SCIP_VARTYPE_BINARY + ); + Edge edge = new Edge(EdgeKey.ofNodes(left.idx, right.idx), edgeVar); + edgesGroupedByNodes.computeIfAbsent(i, ign -> new ArrayList<>()).add(edge); + edgesGroupedByNodes.computeIfAbsent(j, ign -> new ArrayList<>()).add(edge); + edges.add(edge); + } + } + // each node must be connected to exactly 2 edges + List constraints = new ArrayList<>(); + for (int i = 0; i != edgesGroupedByNodes.size(); ++i) { + List edgesForNode = edgesGroupedByNodes.get(i); + double[] values = new double[edgesForNode.size()]; + Arrays.fill(values, 1.0); + Constraint constraint = scip.createConsLinear( + "maxEdges_" + i, + edgesForNode.stream() + .map(e -> e.variable) + .toArray(Variable[]::new), + values, + 2.0, + 2.0 + ); + scip.addCons(constraint); + constraints.add(constraint); + } + + TourFinder tourFinder = new TourFinder(); + SolutionRecorder solutionRecorder = new SolutionRecorder(); + // adding a constraint handler, that inspects solutions found and adds subtour elimination constraints if + // necessary. + scip.addConstraintHandler(new SubtourConstraintGenerator(nodeCount, tourFinder, edges, solutionRecorder)); + + scip.setRealParam("limits/time", 3600.0); + scip.setRealParam("limits/memory", 10000.0); + scip.setLongintParam("limits/totalnodes", 1000); + scip.solve(); + + SCIP_Status status = scip.getStatus(); + System.out.println("Scip status: " + status); + + // extracting the best solution + List> bestSolution = tourFinder.findTours(edges, scip, scip.getBestSol()); + List> shortestTourNodes; + if (bestSolution != null) { + shortestTourNodes = bestSolution + .stream() + .map( + tour -> tour.stream() + .map(p -> p.node) + .collect(Collectors.toList()) + ) + .collect(Collectors.toList()); + solutionRecorder.encounteredSolutions.add(shortestTourNodes); + } else { + System.err.println("!!! No best solution."); + return; + } + + StringBuilder solutionLogMsgBuilder = new StringBuilder("Shortest path: "); + for (Integer node : shortestTourNodes.get(0)) { + solutionLogMsgBuilder.append(" -> ") + .append(node); + } + System.out.println(solutionLogMsgBuilder); + + // writing intermediate solutions and best solution as images + List>> solutions = solutionRecorder.encounteredSolutions; + String formatName = outputImage.substring(outputImage.lastIndexOf('.') + 1); + if (outputImage.contains("%d")) { + for (int i = 0; i != solutions.size(); ++i) { + writeSolutionAsImage(nodes, solutions.get(i), String.format(outputImage, i), formatName); + } + } else { + // only print final solution + writeSolutionAsImage(nodes, shortestTourNodes, outputImage, formatName); + } + scip.writeTransProblem("tsp.ign.lp"); + constraints.forEach(scip::releaseCons); + edges.forEach(e -> scip.releaseVar(e.variable)); + scip.free(); + } + + private static void writeSolutionAsImage( + List nodes, + List> tours, + String outputImage, + String formatName + ) { + BufferedImage image = new BufferedImage(500, 500, BufferedImage.TYPE_INT_RGB); + Graphics2D graphics = image.createGraphics(); + graphics.setColor(Color.BLACK); + graphics.fillRect(0, 0, 500, 500); + graphics.setColor(Color.WHITE); + for (List tour : tours) { + Node previousNode = null; + Integer firstNodeIndex = tour.isEmpty() ? null : tour.get(0); + for (Integer nodeIndex : tour) { + Node currentNode = nodes.get(nodeIndex); + if (previousNode != null) { + graphics.drawLine( + currentNode.x + 50, currentNode.y + 50, + previousNode.x + 50, previousNode.y + 50 + ); + } + previousNode = currentNode; + } + if (firstNodeIndex != null && previousNode != null) { + Node firstNode = nodes.get(firstNodeIndex); + graphics.drawLine( + firstNode.x + 50, firstNode.y + 50, + previousNode.x + 50, previousNode.y + 50 + ); + } + } + graphics.setColor(Color.RED); + for (Node node : nodes) { + graphics.fillArc(node.x - 2 + 50, node.y - 2 + 50, 4, 4, 0, 360); + graphics.drawString(String.valueOf(node.idx), node.x + 60, node.y + 50); + } + try { + ImageIO.write(image, formatName, new File(outputImage)); + } catch (IOException e) { + System.out.println("Could not write image: " + e.getMessage()); + } + } + + private static class Node { + private final int idx; + private final int x; + private final int y; + + private Node(int idx, int x, int y) { + this.idx = idx; + this.x = x; + this.y = y; + } + + private double dist(Node other) { + return StrictMath.sqrt((other.x - x) * (other.x - x) + (other.y - y) * (other.y - y)); + } + + public String toString() { + return "Node: " + idx + ": (" + x + ";" + y + ")"; + } + } + + private static class EdgeKey { + + public static EdgeKey ofNodes(int a, int b) { + if (a == b) { + throw new IllegalArgumentException("Edges cannot connect nodes to themselves."); + } + if (a < b) { + return new EdgeKey(a, b); + } + return new EdgeKey(b, a); + } + + private final int lesser; + private final int higher; + + private EdgeKey(int lesser, int higher) { + this.lesser = lesser; + this.higher = higher; + } + + public int hashCode() { + return lesser * 31 + higher; + } + + public boolean equals(Object other) { + if (this == other) { + return true; + } + if (!(other instanceof EdgeKey)) { + return false; + } + EdgeKey otherEdgeKey = (EdgeKey) other; + return lesser == otherEdgeKey.lesser && higher == otherEdgeKey.higher; + } + + public String toString() { + return "EdgeKey[" + lesser + ":" + higher + "]"; + } + + public boolean connects(int currentNode) { + return lesser == currentNode || higher == currentNode; + } + + } + + private static class Edge { + private final EdgeKey key; + private final Variable variable; + + private Edge(EdgeKey key, Variable variable) { + this.key = key; + this.variable = variable; + } + + public String toString() { + return "Edge: " + key; + } + } + + private static class TourPart { + private final int node; + private final Variable edgeVar; + + private TourPart(int node, Variable edgeVar) { + this.node = node; + this.edgeVar = edgeVar; + } + + public String toString() { + return "TourPart: " + node; + } + } + + private static class SubtourConstraintGenerator extends ConstraintHandler { + + private final int nodeCount; + private final TourFinder tourFinder; + private final List edges; + private final SolutionRecorder solutionRecorder; + + public SubtourConstraintGenerator( + int nodeCount, + TourFinder tourFinder, + List edges, + SolutionRecorder solutionRecorder + ) { + super( + "SubtourExclusion", + "Creates constraints to exclude subtours", + 1_000_000, + -2_000_000, + -2_000_000, + 1, + -1, + 1, + 0, + 0L, + 0L, + 0L, + ScipPropTiming.BEFORELP, + ScipPresolTiming.FAST + ); + this.nodeCount = nodeCount; + this.tourFinder = tourFinder; + this.edges = edges; + this.solutionRecorder = solutionRecorder; + } + + private void log(String message) { + System.out.println("[ExampleLog]: " + message); + } + + @Override + protected SCIP_Retcode check(Scip scip, Solution solution, long checkintegrality, long checklprows, long printreason, long completely, ResultHolder resultHolder) { + log("check"); + List> tours = tourFinder.findTours(edges, scip, solution); + resultHolder.setValue(checkFeasibility(tours)); + return SCIP_Retcode.SCIP_OKAY; + } + + @Override + protected SCIP_Retcode sepalp(Scip scip, ResultHolder resultHolder) { + log("sepalp"); + List> tours = tourFinder.findTours(edges, scip, null); + resultHolder.setValue(separate(scip, tours)); + recordSolution(tours); + return SCIP_Retcode.SCIP_OKAY; + } + + @Override + protected SCIP_Retcode sepasol(Scip scip, Solution solution, ResultHolder resultHolder) { + log("scipExec, stage: " + scip.getStage()); + List> subtours = tourFinder.findTours(edges, scip, solution); + resultHolder.setValue(separate(scip, subtours)); + recordSolution(subtours); + return SCIP_Retcode.SCIP_OKAY; + } + + private void addSubtourConstraints(Scip scip, List> subtours) { + log("Adding <" + subtours.size() + "> subtour constraints."); + for (List subtour : subtours) { + String constraintName = "subtourElimination_" + subtour.stream() + .map(e -> String.valueOf(e.node)) + .collect(Collectors.joining("_")); + Constraint subtourConstraint = scip.createConsLinear( + constraintName, + subtour.stream() + .map(e -> e.edgeVar) + .toArray(Variable[]::new), + subtour.stream() + .mapToDouble(ign -> 1.0) + .toArray(), + - scip.infinity(), + subtour.size() - 1.0 + ); + scip.addCons(subtourConstraint); + scip.releaseCons(subtourConstraint); + } + } + + private SCIP_Result separate(Scip scip, List> subtours) { + if (subtours == null || subtours.isEmpty()) { + return SCIP_Result.SCIP_DIDNOTFIND; + } + if (subtours.size() == 1 && subtours.get(0).size() == nodeCount) { + return SCIP_Result.SCIP_DIDNOTFIND; + } + addSubtourConstraints(scip, subtours); + return SCIP_Result.SCIP_CONSADDED; + } + + private SCIP_Result checkFeasibility(List> subtours) { + if (subtours == null || subtours.size() != 1 || subtours.get(0).size() != nodeCount) { + return SCIP_Result.SCIP_INFEASIBLE; + } + return SCIP_Result.SCIP_FEASIBLE; + } + + private void recordSolution(List> subtours) { + if (subtours == null) { + return; + } + solutionRecorder.encounteredSolutions.add( + subtours.stream() + .map( + l -> l.stream() + .map(p -> p.node) + .collect(Collectors.toList()) + ) + .collect(Collectors.toList()) + ); + } + + @Override + protected SCIP_Retcode enfolp(Scip scip, ResultHolder resultHolder) { + log("enfolp"); + List> tours = tourFinder.findTours(edges, scip, null); + resultHolder.setValue(separate(scip, tours)); + recordSolution(tours); + return SCIP_Retcode.SCIP_OKAY; + } + + } + + private static class TourFinder { + private List> findTours(List edges, Scip scip, Solution solution) { + List activeEdges = new ArrayList<>(); + for (Edge edge : edges) { + if (scip.getSolVal(solution, edge.variable) > 0.5) { + activeEdges.add(edge); + } + } + List> tours = new ArrayList<>(); + while (!activeEdges.isEmpty()) { // If there are no more active edges to process we've found all subtours + List currentTour = new ArrayList<>(); + Edge currentEdge = activeEdges.remove(activeEdges.size() - 1); + int firstNode = currentEdge.key.lesser; + int currentNode = currentEdge.key.higher; + while (currentNode != firstNode) { // otherwise we looped around and the subtour is complete + currentTour.add(new TourPart(currentNode, currentEdge.variable)); + currentEdge = findAndRemoveEdgeForNode(activeEdges, currentNode); + if (currentEdge == null) { + // we don't have a complete loop, so the solution is not feasible. + // could we return any other complete subtour instead? + return null; + } + if (currentNode == currentEdge.key.lesser) { + currentNode = currentEdge.key.higher; + } else { + currentNode = currentEdge.key.lesser; + } + } + currentTour.add(new TourPart(currentNode, currentEdge.variable)); + tours.add(currentTour); + } + return tours; + } + + private Edge findAndRemoveEdgeForNode(List activeEdges, int currentNode) { + Iterator iterator = activeEdges.iterator(); + while(iterator.hasNext()) { + Edge edge = iterator.next(); + if (edge.key.connects(currentNode)) { + iterator.remove(); + return edge; + } + } + return null; + } + } + + private static class SolutionRecorder { + private final List>> encounteredSolutions = new ArrayList<>(); + } + +} diff --git a/java/jscip/ConstraintHandler.java b/java/jscip/ConstraintHandler.java new file mode 100644 index 0000000..4161e55 --- /dev/null +++ b/java/jscip/ConstraintHandler.java @@ -0,0 +1,754 @@ +package jscip; + +public class ConstraintHandler { + + private final String name; + private final String description; + private final int sepapriority; + private final int enfopriority; + private final int checkpriority; + private final int sepafreq; + private final int propfreq; + private final int eagerfreq; + private final int maxprerounds; + private final long delaysepa; + private final long delayprop; + private final long needscons; + private final long proptiming; + private final long presoltiming; + private ObjConshdlr _objConshdlr = null; + + /** + * For parameter descriptions check objconshdlr.h + * + * @param name + * @param description + * @param sepapriority + * @param enfopriority + * @param checkpriority + * @param sepafreq + * @param propfreq + * @param eagerfreq + * @param maxprerounds + * @param delaysepa + * @param delayprop + * @param needscons + * @param proptiming + * @param presoltiming + */ + public ConstraintHandler( + String name, + String description, + int sepapriority, + int enfopriority, + int checkpriority, + int sepafreq, + int propfreq, + int eagerfreq, + int maxprerounds, + long delaysepa, + long delayprop, + long needscons, + long proptiming, + long presoltiming + ) { + this.name = name; + this.description = description; + this.sepapriority = sepapriority; + this.enfopriority = enfopriority; + this.checkpriority = checkpriority; + this.sepafreq = sepafreq; + this.propfreq = propfreq; + this.eagerfreq = eagerfreq; + this.maxprerounds = maxprerounds; + this.delaysepa = delaysepa; + this.delayprop = delayprop; + this.needscons = needscons; + this.proptiming = proptiming; + this.presoltiming = presoltiming; + } + + protected SCIP_Retcode free(Scip scip) { + return SCIP_Retcode.SCIP_OKAY; + } + + protected SCIP_Retcode init(Scip scip) { + return SCIP_Retcode.SCIP_OKAY; + } + + protected SCIP_Retcode exit(Scip scip) { + return SCIP_Retcode.SCIP_OKAY; + } + + protected SCIP_Retcode initpre(Scip scip) { + return SCIP_Retcode.SCIP_OKAY; + } + + protected SCIP_Retcode exitpre(Scip scip) { + return SCIP_Retcode.SCIP_OKAY; + } + + protected SCIP_Retcode initsol(Scip scip) { + return SCIP_Retcode.SCIP_OKAY; + } + + protected SCIP_Retcode exitsol(Scip scip, long restart) { + return SCIP_Retcode.SCIP_OKAY; + } + + protected SCIP_Retcode delete(Scip scip) { + return SCIP_Retcode.SCIP_OKAY; + } + + protected SCIP_Retcode trans(Scip scip) { + return SCIP_Retcode.SCIP_OKAY; + } + + protected SCIP_Retcode initlp(Scip scip, IntHolder infeasible) { + return SCIP_Retcode.SCIP_OKAY; + } + + protected SCIP_Retcode sepalp(Scip scip, ResultHolder result) { + return SCIP_Retcode.SCIP_OKAY; + } + + protected SCIP_Retcode sepasol(Scip scip, Solution solution, ResultHolder result) { + return SCIP_Retcode.SCIP_OKAY; + } + + protected SCIP_Retcode enfolp(Scip scip, ResultHolder result) { + return SCIP_Retcode.SCIP_OKAY; + } + + protected SCIP_Retcode enforelax(Scip scip, ResultHolder result) { + return SCIP_Retcode.SCIP_OKAY; + } + + protected SCIP_Retcode enfops(Scip scip, long solinfeasible, long objinfeasible, ResultHolder result) { + return SCIP_Retcode.SCIP_OKAY; + } + + protected SCIP_Retcode check( + Scip scip, + Solution solution, + long checkintegrality, + long checklprows, + long printreason, + long completely, + ResultHolder result + ) { + return SCIP_Retcode.SCIP_OKAY; + } + + protected SCIP_Retcode prop(Scip scip, ResultHolder result) { + return SCIP_Retcode.SCIP_OKAY; + } + + protected SCIP_Retcode presol(Scip scip, ResultHolder result) { + return SCIP_Retcode.SCIP_OKAY; + } + + protected SCIP_Retcode resprop(Scip scip, ResultHolder result) { + return SCIP_Retcode.SCIP_OKAY; + } + + protected SCIP_Retcode lock(Scip scip, SCIP_LockType locktype, int nlocksneg, int nlockspos) { + return SCIP_Retcode.SCIP_OKAY; + } + + protected SCIP_Retcode active(Scip scip) { + return SCIP_Retcode.SCIP_OKAY; + } + + protected SCIP_Retcode deactive(Scip scip) { + return SCIP_Retcode.SCIP_OKAY; + } + + protected SCIP_Retcode enable(Scip scip) { + return SCIP_Retcode.SCIP_OKAY; + } + + protected SCIP_Retcode disable(Scip scip) { + return SCIP_Retcode.SCIP_OKAY; + } + + protected SCIP_Retcode delvars(Scip scip) { + return SCIP_Retcode.SCIP_OKAY; + } + + protected SCIP_Retcode print(Scip scip) { + return SCIP_Retcode.SCIP_OKAY; + } + + protected SCIP_Retcode copy(Scip scip, IntHolder valid) { + return SCIP_Retcode.SCIP_OKAY; + } + + protected SCIP_Retcode parse(Scip scip, IntHolder success) { + return SCIP_Retcode.SCIP_OKAY; + } + + protected SCIP_Retcode getvars(Scip scip, IntHolder success) { + return SCIP_Retcode.SCIP_OKAY; + } + + protected SCIP_Retcode getnvars(Scip scip, IntHolder nvars, IntHolder success) { + return SCIP_Retcode.SCIP_OKAY; + } + + protected SCIP_Retcode getdivebdchgs( + Scip scip, + Solution solution, + IntHolder success, + IntHolder infeasible + ) { + return SCIP_Retcode.SCIP_OKAY; + } + + protected SCIP_Retcode getpermsymgraph(Scip scip, IntHolder success) { + return SCIP_Retcode.SCIP_OKAY; + } + + protected SCIP_Retcode getsignedpermsymgraph(Scip scip, IntHolder success) { + return SCIP_Retcode.SCIP_OKAY; + } + + public void attach(Scip jScip, SWIGTYPE_p_SCIP cPtr) { + _objConshdlr = new ObjConshdlr( + cPtr, + name, + description, + sepapriority, + enfopriority, + checkpriority, + sepafreq, + propfreq, + eagerfreq, + maxprerounds, + delaysepa, + delayprop, + needscons, + proptiming, + presoltiming + ) { + @Override + public SCIP_Retcode scip_free(SWIGTYPE_p_SCIP scip, SWIGTYPE_p_SCIP_CONSHDLR conshdlr) { + return free(jScip); + } + + @Override + public SCIP_Retcode scip_init( + SWIGTYPE_p_SCIP scip, + SWIGTYPE_p_SCIP_CONSHDLR conshdlr, + SWIGTYPE_p_p_SCIP_CONS conss, + int nconss + ) { + return init(jScip); + } + + @Override + public SCIP_Retcode scip_exit( + SWIGTYPE_p_SCIP scip, + SWIGTYPE_p_SCIP_CONSHDLR conshdlr, + SWIGTYPE_p_p_SCIP_CONS conss, + int nconss + ) { + return exit(jScip); + } + + @Override + public SCIP_Retcode scip_initpre( + SWIGTYPE_p_SCIP scip, + SWIGTYPE_p_SCIP_CONSHDLR conshdlr, + SWIGTYPE_p_p_SCIP_CONS conss, + int nconss + ) { + return initpre(jScip); + } + + @Override + public SCIP_Retcode scip_exitpre( + SWIGTYPE_p_SCIP scip, + SWIGTYPE_p_SCIP_CONSHDLR conshdlr, + SWIGTYPE_p_p_SCIP_CONS conss, + int nconss + ) { + return exitpre(jScip); + } + + @Override + public SCIP_Retcode scip_initsol( + SWIGTYPE_p_SCIP scip, + SWIGTYPE_p_SCIP_CONSHDLR conshdlr, + SWIGTYPE_p_p_SCIP_CONS conss, + int nconss + ) { + return initsol(jScip); + } + + @Override + public SCIP_Retcode scip_exitsol( + SWIGTYPE_p_SCIP scip, + SWIGTYPE_p_SCIP_CONSHDLR conshdlr, + SWIGTYPE_p_p_SCIP_CONS conss, + int nconss, + long restart + ) { + return exitsol(jScip, restart); + } + + @Override + public SCIP_Retcode scip_delete( + SWIGTYPE_p_SCIP scip, + SWIGTYPE_p_SCIP_CONSHDLR conshdlr, + SWIGTYPE_p_SCIP_CONS cons, + SWIGTYPE_p_p_SCIP_CONSDATA consdata + ) { + return ConstraintHandler.this.delete(jScip); + } + + @Override + public SCIP_Retcode scip_trans( + SWIGTYPE_p_SCIP scip, + SWIGTYPE_p_SCIP_CONSHDLR conshdlr, + SWIGTYPE_p_SCIP_CONS sourcecons, + SWIGTYPE_p_p_SCIP_CONS targetcons + ) { + return trans(jScip); + } + + @Override + public SCIP_Retcode scip_initlp( + SWIGTYPE_p_SCIP scip, + SWIGTYPE_p_SCIP_CONSHDLR conshdlr, + SWIGTYPE_p_p_SCIP_CONS conss, + int nconss, + SWIGTYPE_p_unsigned_int infeasible + ) { + IntHolder infeasibleHolder = new IntHolder(); + SCIP_Retcode retCode = initlp(jScip, infeasibleHolder); + if (infeasibleHolder.isSet()) { + SCIPJNI.unsigned_int_array_setitem(infeasible, 0, infeasibleHolder.getValue()); + } + return retCode; + } + + @Override + public SCIP_Retcode scip_sepalp( + SWIGTYPE_p_SCIP scip, + SWIGTYPE_p_SCIP_CONSHDLR conshdlr, + SWIGTYPE_p_p_SCIP_CONS conss, + int nconss, + int nusefulconss, + SWIGTYPE_p_SCIP_Result result + ) { + ResultHolder resultHolder = new ResultHolder(); + SCIP_Retcode retCode = sepalp(jScip, resultHolder); + if (resultHolder.isSet()) { + SCIPJNI.setResult(result, resultHolder.getValue()); + } + return retCode; + } + + @Override + public SCIP_Retcode scip_sepasol( + SWIGTYPE_p_SCIP scip, + SWIGTYPE_p_SCIP_CONSHDLR conshdlr, + SWIGTYPE_p_p_SCIP_CONS conss, + int nconss, + int nusefulconss, + SWIGTYPE_p_SCIP_SOL sol, + SWIGTYPE_p_SCIP_Result result + ) { + ResultHolder resultHolder = new ResultHolder(); + SCIP_Retcode retCode = sepasol(jScip, new Solution(sol), resultHolder); + if (resultHolder.isSet()) { + SCIPJNI.setResult(result, resultHolder.getValue()); + } + return retCode; + } + + @Override + public SCIP_Retcode scip_enfolp( + SWIGTYPE_p_SCIP scip, + SWIGTYPE_p_SCIP_CONSHDLR conshdlr, + SWIGTYPE_p_p_SCIP_CONS conss, + int nconss, + int nusefulconss, + long solinfeasible, + SWIGTYPE_p_SCIP_Result result + ) { + ResultHolder resultHolder = new ResultHolder(); + SCIP_Retcode retCode = enfolp(jScip, resultHolder); + if (resultHolder.isSet()) { + SCIPJNI.setResult(result, resultHolder.getValue()); + } + return retCode; + } + + @Override + public SCIP_Retcode scip_enforelax( + SWIGTYPE_p_SCIP scip, + SWIGTYPE_p_SCIP_SOL sol, + SWIGTYPE_p_SCIP_CONSHDLR conshdlr, + SWIGTYPE_p_p_SCIP_CONS conss, + int nconss, + int nusefulconss, + long solinfeasible, + SWIGTYPE_p_SCIP_Result result + ) { + ResultHolder resultHolder = new ResultHolder(); + SCIP_Retcode retCode = enforelax(jScip, resultHolder); + if (resultHolder.isSet()) { + SCIPJNI.setResult(result, resultHolder.getValue()); + } + return retCode; + } + + @Override + public SCIP_Retcode scip_enfops( + SWIGTYPE_p_SCIP scip, + SWIGTYPE_p_SCIP_CONSHDLR conshdlr, + SWIGTYPE_p_p_SCIP_CONS conss, + int nconss, + int nusefulconss, + long solinfeasible, + long objinfeasible, + SWIGTYPE_p_SCIP_Result result + ) { + ResultHolder resultHolder = new ResultHolder(); + SCIP_Retcode retCode = enfops(jScip, solinfeasible, objinfeasible, resultHolder); + if (resultHolder.isSet()) { + SCIPJNI.setResult(result, resultHolder.getValue()); + } + return retCode; + } + + @Override + public SCIP_Retcode scip_check( + SWIGTYPE_p_SCIP scip, + SWIGTYPE_p_SCIP_CONSHDLR conshdlr, + SWIGTYPE_p_p_SCIP_CONS conss, + int nconss, + SWIGTYPE_p_SCIP_SOL sol, + long checkintegrality, + long checklprows, + long printreason, + long completely, + SWIGTYPE_p_SCIP_Result result + ) { + ResultHolder resultHolder = new ResultHolder(); + SCIP_Retcode retCode = check( + jScip, + new Solution(sol), + checkintegrality, + checklprows, + printreason, + completely, + resultHolder + ); + if (resultHolder.isSet()) { + SCIPJNI.setResult(result, resultHolder.getValue()); + } + return retCode; + } + + @Override + public SCIP_Retcode scip_prop( + SWIGTYPE_p_SCIP scip, + SWIGTYPE_p_SCIP_CONSHDLR conshdlr, + SWIGTYPE_p_p_SCIP_CONS conss, + int nconss, + int nusefulconss, + int nmarkedconss, + SWIGTYPE_p_SCIP_PROPTIMING proptiming, + SWIGTYPE_p_SCIP_Result result + ) { + ResultHolder resultHolder = new ResultHolder(); + SCIP_Retcode retCode = prop(jScip, resultHolder); + if (resultHolder.isSet()) { + SCIPJNI.setResult(result, resultHolder.getValue()); + } + return retCode; + } + + @Override + public SCIP_Retcode scip_presol( + SWIGTYPE_p_SCIP scip, + SWIGTYPE_p_SCIP_CONSHDLR conshdlr, + SWIGTYPE_p_p_SCIP_CONS conss, + int nconss, + int nrounds, + SWIGTYPE_p_SCIP_PRESOLTIMING presoltiming, + int nnewfixedvars, + int nnewaggrvars, + int nnewchgvartypes, + int nnewchgbds, + int nnewholes, + int nnewdelconss, + int nnewaddconss, + int nnewupgdconss, + int nnewchgcoefs, + int nnewchgsides, + SWIGTYPE_p_int nfixedvars, + SWIGTYPE_p_int naggrvars, + SWIGTYPE_p_int nchgvartypes, + SWIGTYPE_p_int nchgbds, + SWIGTYPE_p_int naddholes, + SWIGTYPE_p_int ndelconss, + SWIGTYPE_p_int naddconss, + SWIGTYPE_p_int nupgdconss, + SWIGTYPE_p_int nchgcoefs, + SWIGTYPE_p_int nchgsides, + SWIGTYPE_p_SCIP_Result result + ) { + ResultHolder resultHolder = new ResultHolder(); + SCIP_Retcode retCode = presol(jScip, resultHolder); + if (resultHolder.isSet()) { + SCIPJNI.setResult(result, resultHolder.getValue()); + } + return retCode; + } + + @Override + public SCIP_Retcode scip_resprop( + SWIGTYPE_p_SCIP scip, + SWIGTYPE_p_SCIP_CONSHDLR conshdlr, + SWIGTYPE_p_SCIP_CONS cons, + SWIGTYPE_p_SCIP_VAR infervar, + int inferinfo, + SCIP_BoundType boundtype, + SWIGTYPE_p_SCIP_BDCHGIDX bdchgidx, + double relaxedbd, + SWIGTYPE_p_SCIP_Result result + ) { + ResultHolder resultHolder = new ResultHolder(); + SCIP_Retcode retCode = resprop(jScip, resultHolder); + if (resultHolder.isSet()) { + SCIPJNI.setResult(result, resultHolder.getValue()); + } + return retCode; + } + + @Override + public SCIP_Retcode scip_lock( + SWIGTYPE_p_SCIP scip, + SWIGTYPE_p_SCIP_CONSHDLR conshdlr, + SWIGTYPE_p_SCIP_CONS cons, + SCIP_LockType locktype, + int nlockspos, + int nlocksneg + ) { + return lock(jScip, locktype, nlocksneg, nlockspos); + } + + @Override + public SCIP_Retcode scip_active( + SWIGTYPE_p_SCIP scip, + SWIGTYPE_p_SCIP_CONSHDLR conshdlr, + SWIGTYPE_p_SCIP_CONS cons + ) { + return active(jScip); + } + + @Override + public SCIP_Retcode scip_deactive( + SWIGTYPE_p_SCIP scip, + SWIGTYPE_p_SCIP_CONSHDLR conshdlr, + SWIGTYPE_p_SCIP_CONS cons + ) { + return deactive(jScip); + } + + @Override + public SCIP_Retcode scip_enable( + SWIGTYPE_p_SCIP scip, + SWIGTYPE_p_SCIP_CONSHDLR conshdlr, + SWIGTYPE_p_SCIP_CONS cons + ) { + return enable(jScip); + } + + @Override + public SCIP_Retcode scip_disable( + SWIGTYPE_p_SCIP scip, + SWIGTYPE_p_SCIP_CONSHDLR conshdlr, + SWIGTYPE_p_SCIP_CONS cons + ) { + return disable(jScip); + } + + @Override + public SCIP_Retcode scip_delvars( + SWIGTYPE_p_SCIP scip, + SWIGTYPE_p_SCIP_CONSHDLR conshdlr, + SWIGTYPE_p_p_SCIP_CONS conss, + int nconss + ) { + return delvars(jScip); + } + + @Override + public SCIP_Retcode scip_print( + SWIGTYPE_p_SCIP scip, + SWIGTYPE_p_SCIP_CONSHDLR conshdlr, + SWIGTYPE_p_SCIP_CONS cons, + SWIGTYPE_p_FILE file + ) { + return print(jScip); + } + + @Override + public SCIP_Retcode scip_copy( + SWIGTYPE_p_SCIP scip, + SWIGTYPE_p_p_SCIP_CONS cons, + String name, + SWIGTYPE_p_SCIP sourcescip, + SWIGTYPE_p_SCIP_CONSHDLR sourceconshdlr, + SWIGTYPE_p_SCIP_CONS sourcecons, + SWIGTYPE_p_SCIP_HASHMAP varmap, + SWIGTYPE_p_SCIP_HASHMAP consmap, + long initial, + long separate, + long enforce, + long check, + long propagate, + long local, + long modifiable, + long dynamic, + long removable, + long stickingatnode, + long global, + SWIGTYPE_p_unsigned_int valid + ) { + IntHolder validHolder = new IntHolder(); + SCIP_Retcode retCode = copy(jScip, validHolder); + if (validHolder.isSet()) { + SCIPJNI.unsigned_int_array_setitem(valid, 0, validHolder.getValue()); + } + return retCode; + } + + @Override + public SCIP_Retcode scip_parse( + SWIGTYPE_p_SCIP scip, + SWIGTYPE_p_SCIP_CONSHDLR conshdlr, + SWIGTYPE_p_p_SCIP_CONS cons, + String name, + String str, + long initial, + long separate, + long enforce, + long check, + long propagate, + long local, + long modifiable, + long dynamic, + long removable, + long stickingatnode, + SWIGTYPE_p_unsigned_int success + ) { + IntHolder successHolder = new IntHolder(); + SCIP_Retcode retCode = parse(jScip, successHolder); + if (successHolder.isSet()) { + SCIPJNI.unsigned_int_array_setitem(success, 0, successHolder.getValue()); + } + return retCode; + } + + @Override + public SCIP_Retcode scip_getvars( + SWIGTYPE_p_SCIP scip, + SWIGTYPE_p_SCIP_CONSHDLR conshdlr, + SWIGTYPE_p_SCIP_CONS cons, + SWIGTYPE_p_p_SCIP_VAR vars, + int varssize, + SWIGTYPE_p_unsigned_int success + ) { + IntHolder successHolder = new IntHolder(); + SCIP_Retcode retCode = getvars(jScip, successHolder); + if (successHolder.isSet()) { + SCIPJNI.unsigned_int_array_setitem(success, 0, successHolder.getValue()); + } + return retCode; + } + + @Override + public SCIP_Retcode scip_getnvars( + SWIGTYPE_p_SCIP scip, + SWIGTYPE_p_SCIP_CONSHDLR conshdlr, + SWIGTYPE_p_SCIP_CONS cons, + SWIGTYPE_p_int nvars, + SWIGTYPE_p_unsigned_int success + ) { + IntHolder nvarsHolder = new IntHolder(); + IntHolder successHolder = new IntHolder(); + SCIP_Retcode retCode = getnvars(jScip, nvarsHolder, successHolder); + if (nvarsHolder.isSet()) { + SCIPJNI.int_array_setitem(nvars,0, nvarsHolder.getValue()); + } + if (successHolder.isSet()) { + SCIPJNI.unsigned_int_array_setitem(success, 0, successHolder.getValue()); + } + return retCode; + } + + @Override + public SCIP_Retcode scip_getdivebdchgs( + SWIGTYPE_p_SCIP scip, + SWIGTYPE_p_SCIP_CONSHDLR conshdlr, + SWIGTYPE_p_SCIP_DIVESET diveset, + SWIGTYPE_p_SCIP_SOL sol, + SWIGTYPE_p_unsigned_int success, + SWIGTYPE_p_unsigned_int infeasible + ) { + Solution solution = new Solution(sol); + IntHolder successHolder = new IntHolder(); + IntHolder infeasibleHolder = new IntHolder(); + SCIP_Retcode retcode = getdivebdchgs(jScip, solution, successHolder, infeasibleHolder); + if (successHolder.isSet()) { + SCIPJNI.unsigned_int_array_setitem(success, 0, successHolder.getValue()); + } + if (infeasibleHolder.isSet()) { + SCIPJNI.unsigned_int_array_setitem(infeasible, 0, infeasibleHolder.getValue()); + } + return retcode; + } + + @Override + public SCIP_Retcode scip_getpermsymgraph( + SWIGTYPE_p_SCIP scip, + SWIGTYPE_p_SCIP_CONSHDLR conshdlr, + SWIGTYPE_p_SCIP_CONS cons, + SWIGTYPE_p_SYM_GRAPH graph, + SWIGTYPE_p_unsigned_int success + ) { + IntHolder successHolder = new IntHolder(); + SCIP_Retcode retCode = getpermsymgraph(jScip, successHolder); + if (successHolder.isSet()) { + SCIPJNI.unsigned_int_array_setitem(success, 0, successHolder.getValue()); + } + return retCode; + } + + @Override + public SCIP_Retcode scip_getsignedpermsymgraph( + SWIGTYPE_p_SCIP scip, + SWIGTYPE_p_SCIP_CONSHDLR conshdlr, + SWIGTYPE_p_SCIP_CONS cons, + SWIGTYPE_p_SYM_GRAPH graph, + SWIGTYPE_p_unsigned_int success + ) { + IntHolder successHolder = new IntHolder(); + SCIP_Retcode retCode = getsignedpermsymgraph(jScip, successHolder); + if (successHolder.isSet()) { + SCIPJNI.unsigned_int_array_setitem(success, 0, successHolder.getValue()); + } + return retCode; + } + }; + SCIPJNI.SCIPincludeObjConshdlr(cPtr, _objConshdlr, 1L); + _objConshdlr.swigReleaseOwnership(); + } + +} diff --git a/java/jscip/EventHandler.java b/java/jscip/EventHandler.java new file mode 100644 index 0000000..ca86ba1 --- /dev/null +++ b/java/jscip/EventHandler.java @@ -0,0 +1,108 @@ +package jscip; + +public class EventHandler { + + private final String name; + private final String description; + private final long events; + private ObjEventhdlr _objEventhdlr = null; + + public EventHandler(String name, String description, long events) { + this.name = name; + this.description = description; + this.events = events; + } + + protected SCIP_Retcode scipFree(Scip scip) { + return SCIP_Retcode.SCIP_OKAY; + } + + protected SCIP_Retcode scipInit(Scip scip) { + return SCIP_Retcode.SCIP_OKAY; + } + + protected SCIP_Retcode scipExit(Scip scip) { + return SCIP_Retcode.SCIP_OKAY; + } + + protected SCIP_Retcode scipInitsol(Scip scip) { + return SCIP_Retcode.SCIP_OKAY; + } + + protected SCIP_Retcode scipExitsol(Scip scip) { + return SCIP_Retcode.SCIP_OKAY; + } + + protected SCIP_Retcode scipDelete(Scip scip) { + return SCIP_Retcode.SCIP_OKAY; + } + + protected SCIP_Retcode scipExec(Scip scip, SCIP_Event event) { + return SCIP_Retcode.SCIP_OKAY; + } + + public String getName() { + return this.name; + } + + public String getDescription() { + return this.description; + } + + void attach(Scip scip, SWIGTYPE_p_SCIP scipptr) { + this._objEventhdlr = new ObjEventhdlr(scipptr, name, description) { + @Override + public SCIP_Retcode scip_free(SWIGTYPE_p_SCIP scipptr, SWIGTYPE_p_SCIP_EVENTHDLR eventhdlr) { + return scipFree(scip); + } + + @Override + public SCIP_Retcode scip_init(SWIGTYPE_p_SCIP scipptr, SWIGTYPE_p_SCIP_EVENTHDLR eventhdlr) { + SCIPJNI.SCIPcatchEvent( + scipptr, + events, + eventhdlr, + null, + null + ); + return scipInit(scip); + } + + @Override + public SCIP_Retcode scip_exit(SWIGTYPE_p_SCIP scipptr, SWIGTYPE_p_SCIP_EVENTHDLR eventhdlr) { + return scipExit(scip); + } + + @Override + public SCIP_Retcode scip_initsol(SWIGTYPE_p_SCIP scipptr, SWIGTYPE_p_SCIP_EVENTHDLR eventhdlr) { + return scipInitsol(scip); + } + + @Override + public SCIP_Retcode scip_exitsol(SWIGTYPE_p_SCIP scipptr, SWIGTYPE_p_SCIP_EVENTHDLR eventhdlr) { + return scipExitsol(scip); + } + + @Override + public SCIP_Retcode scip_delete( + SWIGTYPE_p_SCIP scipptr, + SWIGTYPE_p_SCIP_EVENTHDLR eventhdlr, + SWIGTYPE_p_p_SCIP_EVENTDATA eventdata + ) { + return scipDelete(scip); + } + + @Override + public SCIP_Retcode scip_exec( + SWIGTYPE_p_SCIP scipptr, + SWIGTYPE_p_SCIP_EVENTHDLR eventhdlr, + SCIP_Event event, + SWIGTYPE_p_SCIP_EVENTDATA eventdata + ) { + return scipExec(scip, event); + } + }; + SCIPJNI.SCIPincludeObjEventhdlr(scipptr, _objEventhdlr, 1L); + } + +} diff --git a/java/jscip/EventType.java b/java/jscip/EventType.java new file mode 100644 index 0000000..4235d46 --- /dev/null +++ b/java/jscip/EventType.java @@ -0,0 +1,100 @@ +package jscip; + +/** + * See type_event.h + */ +public class EventType { + + public static final long DISABLED = 0x000000000L; + + /* variable events */ + public static final long VARADDED = 0x000000001L; + public static final long VARDELETED = 0x000000002L; + public static final long VARFIXED = 0x000000004L; + public static final long VARUNLOCKED = 0x000000008L; + public static final long OBJCHANGED = 0x000000010L; + public static final long GLBCHANGED = 0x000000020L; + public static final long GUBCHANGED = 0x000000040L; + public static final long LBTIGHTENED = 0x000000080L; + public static final long LBRELAXED = 0x000000100L; + public static final long UBTIGHTENED = 0x000000200L; + public static final long UBRELAXED = 0x000000400L; + public static final long GHOLEADDED = 0x000000800L; + public static final long GHOLEREMOVED = 0x000001000L; + public static final long LHOLEADDED = 0x000002000L; + public static final long LHOLEREMOVED = 0x000004000L; + public static final long IMPLADDED = 0x000008000L; + public static final long TYPECHANGED = 0x000010000L; + + /* presolving events */ + public static final long PRESOLVEROUND = 0x000020000L; + + /* node events */ + public static final long NODEFOCUSED = 0x000040000L; + public static final long NODEFEASIBLE = 0x000080000L; + public static final long NODEINFEASIBLE = 0x000100000L; + public static final long NODEBRANCHED = 0x000200000L; + public static final long NODEDELETE = 0x000400000L; + + + /* LP events */ + public static final long FIRSTLPSOLVED = 0x000800000L; + public static final long LPSOLVED = 0x001000000L; + + /* primal solution events */ + public static final long POORSOLFOUND = 0x002000000L; + public static final long BESTSOLFOUND = 0x004000000L; + + /* linear row events */ + public static final long ROWADDEDSEPA = 0x008000000L; + public static final long ROWDELETEDSEPA = 0x010000000L; + public static final long ROWADDEDLP = 0x020000000L; + public static final long ROWDELETEDLP = 0x040000000L; + public static final long ROWCOEFCHANGED = 0x080000000L; + public static final long ROWCONSTCHANGED = 0x100000000L; + public static final long ROWSIDECHANGED = 0x200000000L; + + /* sync event */ + public static final long SYNC = 0x400000000L; + + /* event masks for variable events */ + public static final long GBDCHANGED = GLBCHANGED | GUBCHANGED; + public static final long LBCHANGED = LBTIGHTENED | LBRELAXED; + public static final long UBCHANGED = UBTIGHTENED | UBRELAXED; + public static final long BOUNDTIGHTENED = LBTIGHTENED | UBTIGHTENED; + public static final long BOUNDRELAXED = LBRELAXED | UBRELAXED; + public static final long BOUNDCHANGED = LBCHANGED | UBCHANGED; + public static final long GHOLECHANGED = GHOLEADDED | GHOLEREMOVED; + public static final long LHOLECHANGED = LHOLEADDED | LHOLEREMOVED; + public static final long HOLECHANGED = GHOLECHANGED | LHOLECHANGED; + public static final long DOMCHANGED = BOUNDCHANGED | HOLECHANGED; + public static final long VARCHANGED = VARFIXED + | VARUNLOCKED + | OBJCHANGED + | GBDCHANGED + | DOMCHANGED + | IMPLADDED + | VARDELETED + | TYPECHANGED; + public static final long VAREVENT = VARADDED | VARCHANGED | TYPECHANGED; + + /* event masks for node events */ + public static final long NODESOLVED = NODEFEASIBLE | NODEINFEASIBLE | NODEBRANCHED; + public static final long NODEEVENT = NODEFOCUSED | NODESOLVED; + + /* event masks for LP events */ + public static final long LPEVENT = FIRSTLPSOLVED | LPSOLVED; + + /* event masks for primal solution events */ + public static final long SOLFOUND = POORSOLFOUND | BESTSOLFOUND; + public static final long SOLEVENT = SOLFOUND; + + /* event masks for row events */ + public static final long ROWCHANGED = ROWCOEFCHANGED | ROWCONSTCHANGED | ROWSIDECHANGED; + public static final long ROWEVENT = ROWADDEDSEPA | ROWDELETEDSEPA | ROWADDEDLP | ROWDELETEDLP | ROWCHANGED; + + private EventType() { + throw new IllegalStateException("Utility class"); + } + +} diff --git a/java/jscip/IntHolder.java b/java/jscip/IntHolder.java new file mode 100644 index 0000000..288bd29 --- /dev/null +++ b/java/jscip/IntHolder.java @@ -0,0 +1,21 @@ +package jscip; + +public class IntHolder { + + private int value = 0; + private boolean set = false; + + public int getValue() { + return value; + } + + public boolean isSet() { + return set; + } + + public void setValue(int value) { + this.value = value; + set = true; + } + +} diff --git a/java/jscip/ObjConshdlr.java b/java/jscip/ObjConshdlr.java new file mode 100644 index 0000000..d14f428 --- /dev/null +++ b/java/jscip/ObjConshdlr.java @@ -0,0 +1,264 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package jscip; + +public class ObjConshdlr { + private transient long swigCPtr; + protected transient boolean swigCMemOwn; + + protected ObjConshdlr(long cPtr, boolean cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = cPtr; + } + + protected static long getCPtr(ObjConshdlr obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + @SuppressWarnings("deprecation") + protected void finalize() { + delete(); + } + + public synchronized void delete() { + if (swigCPtr != 0) { + if (swigCMemOwn) { + swigCMemOwn = false; + SCIPJNIJNI.delete_ObjConshdlr(swigCPtr); + } + swigCPtr = 0; + } + } + + protected void swigDirectorDisconnect() { + swigCMemOwn = false; + delete(); + } + + public void swigReleaseOwnership() { + swigCMemOwn = false; + SCIPJNIJNI.ObjConshdlr_change_ownership(this, swigCPtr, false); + } + + public void swigTakeOwnership() { + swigCMemOwn = true; + SCIPJNIJNI.ObjConshdlr_change_ownership(this, swigCPtr, true); + } + + public void setScip_(SWIGTYPE_p_SCIP value) { + SCIPJNIJNI.ObjConshdlr_scip__set(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(value)); + } + + public SWIGTYPE_p_SCIP getScip_() { + long cPtr = SCIPJNIJNI.ObjConshdlr_scip__get(swigCPtr, this); + return (cPtr == 0) ? null : new SWIGTYPE_p_SCIP(cPtr, false); + } + + public void setScip_name_(String value) { + SCIPJNIJNI.ObjConshdlr_scip_name__set(swigCPtr, this, value); + } + + public String getScip_name_() { + return SCIPJNIJNI.ObjConshdlr_scip_name__get(swigCPtr, this); + } + + public void setScip_desc_(String value) { + SCIPJNIJNI.ObjConshdlr_scip_desc__set(swigCPtr, this, value); + } + + public String getScip_desc_() { + return SCIPJNIJNI.ObjConshdlr_scip_desc__get(swigCPtr, this); + } + + public int getScip_sepapriority_() { + return SCIPJNIJNI.ObjConshdlr_scip_sepapriority__get(swigCPtr, this); + } + + public int getScip_enfopriority_() { + return SCIPJNIJNI.ObjConshdlr_scip_enfopriority__get(swigCPtr, this); + } + + public int getScip_checkpriority_() { + return SCIPJNIJNI.ObjConshdlr_scip_checkpriority__get(swigCPtr, this); + } + + public int getScip_sepafreq_() { + return SCIPJNIJNI.ObjConshdlr_scip_sepafreq__get(swigCPtr, this); + } + + public int getScip_propfreq_() { + return SCIPJNIJNI.ObjConshdlr_scip_propfreq__get(swigCPtr, this); + } + + public int getScip_eagerfreq_() { + return SCIPJNIJNI.ObjConshdlr_scip_eagerfreq__get(swigCPtr, this); + } + + public int getScip_maxprerounds_() { + return SCIPJNIJNI.ObjConshdlr_scip_maxprerounds__get(swigCPtr, this); + } + + public long getScip_delaysepa_() { + return SCIPJNIJNI.ObjConshdlr_scip_delaysepa__get(swigCPtr, this); + } + + public long getScip_delayprop_() { + return SCIPJNIJNI.ObjConshdlr_scip_delayprop__get(swigCPtr, this); + } + + public long getScip_needscons_() { + return SCIPJNIJNI.ObjConshdlr_scip_needscons__get(swigCPtr, this); + } + + public long getScip_proptiming_() { + return SCIPJNIJNI.ObjConshdlr_scip_proptiming__get(swigCPtr, this); + } + + public long getScip_presoltiming_() { + return SCIPJNIJNI.ObjConshdlr_scip_presoltiming__get(swigCPtr, this); + } + + public ObjConshdlr(SWIGTYPE_p_SCIP scip, String name, String desc, int sepapriority, int enfopriority, int checkpriority, int sepafreq, int propfreq, int eagerfreq, int scip_maxprerounds, long delaysepa, long delayprop, long needscons, long proptiming, long presoltiming) { + this(SCIPJNIJNI.new_ObjConshdlr(SWIGTYPE_p_SCIP.getCPtr(scip), name, desc, sepapriority, enfopriority, checkpriority, sepafreq, propfreq, eagerfreq, scip_maxprerounds, delaysepa, delayprop, needscons, proptiming, presoltiming), true); + SCIPJNIJNI.ObjConshdlr_director_connect(this, swigCPtr, true, true); + } + + public SCIP_Retcode scip_free(SWIGTYPE_p_SCIP scip, SWIGTYPE_p_SCIP_CONSHDLR conshdlr) { + return SCIP_Retcode.swigToEnum((getClass() == ObjConshdlr.class) ? SCIPJNIJNI.ObjConshdlr_scip_free(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr)) : SCIPJNIJNI.ObjConshdlr_scip_freeSwigExplicitObjConshdlr(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr))); + } + + public SCIP_Retcode scip_init(SWIGTYPE_p_SCIP scip, SWIGTYPE_p_SCIP_CONSHDLR conshdlr, SWIGTYPE_p_p_SCIP_CONS conss, int nconss) { + return SCIP_Retcode.swigToEnum((getClass() == ObjConshdlr.class) ? SCIPJNIJNI.ObjConshdlr_scip_init(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_p_SCIP_CONS.getCPtr(conss), nconss) : SCIPJNIJNI.ObjConshdlr_scip_initSwigExplicitObjConshdlr(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_p_SCIP_CONS.getCPtr(conss), nconss)); + } + + public SCIP_Retcode scip_exit(SWIGTYPE_p_SCIP scip, SWIGTYPE_p_SCIP_CONSHDLR conshdlr, SWIGTYPE_p_p_SCIP_CONS conss, int nconss) { + return SCIP_Retcode.swigToEnum((getClass() == ObjConshdlr.class) ? SCIPJNIJNI.ObjConshdlr_scip_exit(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_p_SCIP_CONS.getCPtr(conss), nconss) : SCIPJNIJNI.ObjConshdlr_scip_exitSwigExplicitObjConshdlr(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_p_SCIP_CONS.getCPtr(conss), nconss)); + } + + public SCIP_Retcode scip_initpre(SWIGTYPE_p_SCIP scip, SWIGTYPE_p_SCIP_CONSHDLR conshdlr, SWIGTYPE_p_p_SCIP_CONS conss, int nconss) { + return SCIP_Retcode.swigToEnum((getClass() == ObjConshdlr.class) ? SCIPJNIJNI.ObjConshdlr_scip_initpre(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_p_SCIP_CONS.getCPtr(conss), nconss) : SCIPJNIJNI.ObjConshdlr_scip_initpreSwigExplicitObjConshdlr(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_p_SCIP_CONS.getCPtr(conss), nconss)); + } + + public SCIP_Retcode scip_exitpre(SWIGTYPE_p_SCIP scip, SWIGTYPE_p_SCIP_CONSHDLR conshdlr, SWIGTYPE_p_p_SCIP_CONS conss, int nconss) { + return SCIP_Retcode.swigToEnum((getClass() == ObjConshdlr.class) ? SCIPJNIJNI.ObjConshdlr_scip_exitpre(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_p_SCIP_CONS.getCPtr(conss), nconss) : SCIPJNIJNI.ObjConshdlr_scip_exitpreSwigExplicitObjConshdlr(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_p_SCIP_CONS.getCPtr(conss), nconss)); + } + + public SCIP_Retcode scip_initsol(SWIGTYPE_p_SCIP scip, SWIGTYPE_p_SCIP_CONSHDLR conshdlr, SWIGTYPE_p_p_SCIP_CONS conss, int nconss) { + return SCIP_Retcode.swigToEnum((getClass() == ObjConshdlr.class) ? SCIPJNIJNI.ObjConshdlr_scip_initsol(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_p_SCIP_CONS.getCPtr(conss), nconss) : SCIPJNIJNI.ObjConshdlr_scip_initsolSwigExplicitObjConshdlr(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_p_SCIP_CONS.getCPtr(conss), nconss)); + } + + public SCIP_Retcode scip_exitsol(SWIGTYPE_p_SCIP scip, SWIGTYPE_p_SCIP_CONSHDLR conshdlr, SWIGTYPE_p_p_SCIP_CONS conss, int nconss, long restart) { + return SCIP_Retcode.swigToEnum((getClass() == ObjConshdlr.class) ? SCIPJNIJNI.ObjConshdlr_scip_exitsol(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_p_SCIP_CONS.getCPtr(conss), nconss, restart) : SCIPJNIJNI.ObjConshdlr_scip_exitsolSwigExplicitObjConshdlr(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_p_SCIP_CONS.getCPtr(conss), nconss, restart)); + } + + public SCIP_Retcode scip_delete(SWIGTYPE_p_SCIP scip, SWIGTYPE_p_SCIP_CONSHDLR conshdlr, SWIGTYPE_p_SCIP_CONS cons, SWIGTYPE_p_p_SCIP_CONSDATA consdata) { + return SCIP_Retcode.swigToEnum((getClass() == ObjConshdlr.class) ? SCIPJNIJNI.ObjConshdlr_scip_delete(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_SCIP_CONS.getCPtr(cons), SWIGTYPE_p_p_SCIP_CONSDATA.getCPtr(consdata)) : SCIPJNIJNI.ObjConshdlr_scip_deleteSwigExplicitObjConshdlr(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_SCIP_CONS.getCPtr(cons), SWIGTYPE_p_p_SCIP_CONSDATA.getCPtr(consdata))); + } + + public SCIP_Retcode scip_trans(SWIGTYPE_p_SCIP scip, SWIGTYPE_p_SCIP_CONSHDLR conshdlr, SWIGTYPE_p_SCIP_CONS sourcecons, SWIGTYPE_p_p_SCIP_CONS targetcons) { + return SCIP_Retcode.swigToEnum((getClass() == ObjConshdlr.class) ? SCIPJNIJNI.ObjConshdlr_scip_trans(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_SCIP_CONS.getCPtr(sourcecons), SWIGTYPE_p_p_SCIP_CONS.getCPtr(targetcons)) : SCIPJNIJNI.ObjConshdlr_scip_transSwigExplicitObjConshdlr(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_SCIP_CONS.getCPtr(sourcecons), SWIGTYPE_p_p_SCIP_CONS.getCPtr(targetcons))); + } + + public SCIP_Retcode scip_initlp(SWIGTYPE_p_SCIP scip, SWIGTYPE_p_SCIP_CONSHDLR conshdlr, SWIGTYPE_p_p_SCIP_CONS conss, int nconss, SWIGTYPE_p_unsigned_int infeasible) { + return SCIP_Retcode.swigToEnum((getClass() == ObjConshdlr.class) ? SCIPJNIJNI.ObjConshdlr_scip_initlp(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_p_SCIP_CONS.getCPtr(conss), nconss, SWIGTYPE_p_unsigned_int.getCPtr(infeasible)) : SCIPJNIJNI.ObjConshdlr_scip_initlpSwigExplicitObjConshdlr(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_p_SCIP_CONS.getCPtr(conss), nconss, SWIGTYPE_p_unsigned_int.getCPtr(infeasible))); + } + + public SCIP_Retcode scip_sepalp(SWIGTYPE_p_SCIP scip, SWIGTYPE_p_SCIP_CONSHDLR conshdlr, SWIGTYPE_p_p_SCIP_CONS conss, int nconss, int nusefulconss, SWIGTYPE_p_SCIP_Result result) { + return SCIP_Retcode.swigToEnum((getClass() == ObjConshdlr.class) ? SCIPJNIJNI.ObjConshdlr_scip_sepalp(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_p_SCIP_CONS.getCPtr(conss), nconss, nusefulconss, SWIGTYPE_p_SCIP_Result.getCPtr(result)) : SCIPJNIJNI.ObjConshdlr_scip_sepalpSwigExplicitObjConshdlr(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_p_SCIP_CONS.getCPtr(conss), nconss, nusefulconss, SWIGTYPE_p_SCIP_Result.getCPtr(result))); + } + + public SCIP_Retcode scip_sepasol(SWIGTYPE_p_SCIP scip, SWIGTYPE_p_SCIP_CONSHDLR conshdlr, SWIGTYPE_p_p_SCIP_CONS conss, int nconss, int nusefulconss, SWIGTYPE_p_SCIP_SOL sol, SWIGTYPE_p_SCIP_Result result) { + return SCIP_Retcode.swigToEnum((getClass() == ObjConshdlr.class) ? SCIPJNIJNI.ObjConshdlr_scip_sepasol(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_p_SCIP_CONS.getCPtr(conss), nconss, nusefulconss, SWIGTYPE_p_SCIP_SOL.getCPtr(sol), SWIGTYPE_p_SCIP_Result.getCPtr(result)) : SCIPJNIJNI.ObjConshdlr_scip_sepasolSwigExplicitObjConshdlr(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_p_SCIP_CONS.getCPtr(conss), nconss, nusefulconss, SWIGTYPE_p_SCIP_SOL.getCPtr(sol), SWIGTYPE_p_SCIP_Result.getCPtr(result))); + } + + public SCIP_Retcode scip_enfolp(SWIGTYPE_p_SCIP scip, SWIGTYPE_p_SCIP_CONSHDLR conshdlr, SWIGTYPE_p_p_SCIP_CONS conss, int nconss, int nusefulconss, long solinfeasible, SWIGTYPE_p_SCIP_Result result) { + return SCIP_Retcode.swigToEnum((getClass() == ObjConshdlr.class) ? SCIPJNIJNI.ObjConshdlr_scip_enfolp(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_p_SCIP_CONS.getCPtr(conss), nconss, nusefulconss, solinfeasible, SWIGTYPE_p_SCIP_Result.getCPtr(result)) : SCIPJNIJNI.ObjConshdlr_scip_enfolpSwigExplicitObjConshdlr(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_p_SCIP_CONS.getCPtr(conss), nconss, nusefulconss, solinfeasible, SWIGTYPE_p_SCIP_Result.getCPtr(result))); + } + + public SCIP_Retcode scip_enforelax(SWIGTYPE_p_SCIP scip, SWIGTYPE_p_SCIP_SOL sol, SWIGTYPE_p_SCIP_CONSHDLR conshdlr, SWIGTYPE_p_p_SCIP_CONS conss, int nconss, int nusefulconss, long solinfeasible, SWIGTYPE_p_SCIP_Result result) { + return SCIP_Retcode.swigToEnum((getClass() == ObjConshdlr.class) ? SCIPJNIJNI.ObjConshdlr_scip_enforelax(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_SOL.getCPtr(sol), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_p_SCIP_CONS.getCPtr(conss), nconss, nusefulconss, solinfeasible, SWIGTYPE_p_SCIP_Result.getCPtr(result)) : SCIPJNIJNI.ObjConshdlr_scip_enforelaxSwigExplicitObjConshdlr(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_SOL.getCPtr(sol), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_p_SCIP_CONS.getCPtr(conss), nconss, nusefulconss, solinfeasible, SWIGTYPE_p_SCIP_Result.getCPtr(result))); + } + + public SCIP_Retcode scip_enfops(SWIGTYPE_p_SCIP scip, SWIGTYPE_p_SCIP_CONSHDLR conshdlr, SWIGTYPE_p_p_SCIP_CONS conss, int nconss, int nusefulconss, long solinfeasible, long objinfeasible, SWIGTYPE_p_SCIP_Result result) { + return SCIP_Retcode.swigToEnum((getClass() == ObjConshdlr.class) ? SCIPJNIJNI.ObjConshdlr_scip_enfops(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_p_SCIP_CONS.getCPtr(conss), nconss, nusefulconss, solinfeasible, objinfeasible, SWIGTYPE_p_SCIP_Result.getCPtr(result)) : SCIPJNIJNI.ObjConshdlr_scip_enfopsSwigExplicitObjConshdlr(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_p_SCIP_CONS.getCPtr(conss), nconss, nusefulconss, solinfeasible, objinfeasible, SWIGTYPE_p_SCIP_Result.getCPtr(result))); + } + + public SCIP_Retcode scip_check(SWIGTYPE_p_SCIP scip, SWIGTYPE_p_SCIP_CONSHDLR conshdlr, SWIGTYPE_p_p_SCIP_CONS conss, int nconss, SWIGTYPE_p_SCIP_SOL sol, long checkintegrality, long checklprows, long printreason, long completely, SWIGTYPE_p_SCIP_Result result) { + return SCIP_Retcode.swigToEnum((getClass() == ObjConshdlr.class) ? SCIPJNIJNI.ObjConshdlr_scip_check(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_p_SCIP_CONS.getCPtr(conss), nconss, SWIGTYPE_p_SCIP_SOL.getCPtr(sol), checkintegrality, checklprows, printreason, completely, SWIGTYPE_p_SCIP_Result.getCPtr(result)) : SCIPJNIJNI.ObjConshdlr_scip_checkSwigExplicitObjConshdlr(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_p_SCIP_CONS.getCPtr(conss), nconss, SWIGTYPE_p_SCIP_SOL.getCPtr(sol), checkintegrality, checklprows, printreason, completely, SWIGTYPE_p_SCIP_Result.getCPtr(result))); + } + + public SCIP_Retcode scip_prop(SWIGTYPE_p_SCIP scip, SWIGTYPE_p_SCIP_CONSHDLR conshdlr, SWIGTYPE_p_p_SCIP_CONS conss, int nconss, int nusefulconss, int nmarkedconss, SWIGTYPE_p_SCIP_PROPTIMING proptiming, SWIGTYPE_p_SCIP_Result result) { + return SCIP_Retcode.swigToEnum((getClass() == ObjConshdlr.class) ? SCIPJNIJNI.ObjConshdlr_scip_prop(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_p_SCIP_CONS.getCPtr(conss), nconss, nusefulconss, nmarkedconss, SWIGTYPE_p_SCIP_PROPTIMING.getCPtr(proptiming), SWIGTYPE_p_SCIP_Result.getCPtr(result)) : SCIPJNIJNI.ObjConshdlr_scip_propSwigExplicitObjConshdlr(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_p_SCIP_CONS.getCPtr(conss), nconss, nusefulconss, nmarkedconss, SWIGTYPE_p_SCIP_PROPTIMING.getCPtr(proptiming), SWIGTYPE_p_SCIP_Result.getCPtr(result))); + } + + public SCIP_Retcode scip_presol(SWIGTYPE_p_SCIP scip, SWIGTYPE_p_SCIP_CONSHDLR conshdlr, SWIGTYPE_p_p_SCIP_CONS conss, int nconss, int nrounds, SWIGTYPE_p_SCIP_PRESOLTIMING presoltiming, int nnewfixedvars, int nnewaggrvars, int nnewchgvartypes, int nnewchgbds, int nnewholes, int nnewdelconss, int nnewaddconss, int nnewupgdconss, int nnewchgcoefs, int nnewchgsides, SWIGTYPE_p_int nfixedvars, SWIGTYPE_p_int naggrvars, SWIGTYPE_p_int nchgvartypes, SWIGTYPE_p_int nchgbds, SWIGTYPE_p_int naddholes, SWIGTYPE_p_int ndelconss, SWIGTYPE_p_int naddconss, SWIGTYPE_p_int nupgdconss, SWIGTYPE_p_int nchgcoefs, SWIGTYPE_p_int nchgsides, SWIGTYPE_p_SCIP_Result result) { + return SCIP_Retcode.swigToEnum((getClass() == ObjConshdlr.class) ? SCIPJNIJNI.ObjConshdlr_scip_presol(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_p_SCIP_CONS.getCPtr(conss), nconss, nrounds, SWIGTYPE_p_SCIP_PRESOLTIMING.getCPtr(presoltiming), nnewfixedvars, nnewaggrvars, nnewchgvartypes, nnewchgbds, nnewholes, nnewdelconss, nnewaddconss, nnewupgdconss, nnewchgcoefs, nnewchgsides, SWIGTYPE_p_int.getCPtr(nfixedvars), SWIGTYPE_p_int.getCPtr(naggrvars), SWIGTYPE_p_int.getCPtr(nchgvartypes), SWIGTYPE_p_int.getCPtr(nchgbds), SWIGTYPE_p_int.getCPtr(naddholes), SWIGTYPE_p_int.getCPtr(ndelconss), SWIGTYPE_p_int.getCPtr(naddconss), SWIGTYPE_p_int.getCPtr(nupgdconss), SWIGTYPE_p_int.getCPtr(nchgcoefs), SWIGTYPE_p_int.getCPtr(nchgsides), SWIGTYPE_p_SCIP_Result.getCPtr(result)) : SCIPJNIJNI.ObjConshdlr_scip_presolSwigExplicitObjConshdlr(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_p_SCIP_CONS.getCPtr(conss), nconss, nrounds, SWIGTYPE_p_SCIP_PRESOLTIMING.getCPtr(presoltiming), nnewfixedvars, nnewaggrvars, nnewchgvartypes, nnewchgbds, nnewholes, nnewdelconss, nnewaddconss, nnewupgdconss, nnewchgcoefs, nnewchgsides, SWIGTYPE_p_int.getCPtr(nfixedvars), SWIGTYPE_p_int.getCPtr(naggrvars), SWIGTYPE_p_int.getCPtr(nchgvartypes), SWIGTYPE_p_int.getCPtr(nchgbds), SWIGTYPE_p_int.getCPtr(naddholes), SWIGTYPE_p_int.getCPtr(ndelconss), SWIGTYPE_p_int.getCPtr(naddconss), SWIGTYPE_p_int.getCPtr(nupgdconss), SWIGTYPE_p_int.getCPtr(nchgcoefs), SWIGTYPE_p_int.getCPtr(nchgsides), SWIGTYPE_p_SCIP_Result.getCPtr(result))); + } + + public SCIP_Retcode scip_resprop(SWIGTYPE_p_SCIP scip, SWIGTYPE_p_SCIP_CONSHDLR conshdlr, SWIGTYPE_p_SCIP_CONS cons, SWIGTYPE_p_SCIP_VAR infervar, int inferinfo, SCIP_BoundType boundtype, SWIGTYPE_p_SCIP_BDCHGIDX bdchgidx, double relaxedbd, SWIGTYPE_p_SCIP_Result result) { + return SCIP_Retcode.swigToEnum((getClass() == ObjConshdlr.class) ? SCIPJNIJNI.ObjConshdlr_scip_resprop(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_SCIP_CONS.getCPtr(cons), SWIGTYPE_p_SCIP_VAR.getCPtr(infervar), inferinfo, boundtype.swigValue(), SWIGTYPE_p_SCIP_BDCHGIDX.getCPtr(bdchgidx), relaxedbd, SWIGTYPE_p_SCIP_Result.getCPtr(result)) : SCIPJNIJNI.ObjConshdlr_scip_respropSwigExplicitObjConshdlr(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_SCIP_CONS.getCPtr(cons), SWIGTYPE_p_SCIP_VAR.getCPtr(infervar), inferinfo, boundtype.swigValue(), SWIGTYPE_p_SCIP_BDCHGIDX.getCPtr(bdchgidx), relaxedbd, SWIGTYPE_p_SCIP_Result.getCPtr(result))); + } + + public SCIP_Retcode scip_lock(SWIGTYPE_p_SCIP scip, SWIGTYPE_p_SCIP_CONSHDLR conshdlr, SWIGTYPE_p_SCIP_CONS cons, SCIP_LockType locktype, int nlockspos, int nlocksneg) { + return SCIP_Retcode.swigToEnum((getClass() == ObjConshdlr.class) ? SCIPJNIJNI.ObjConshdlr_scip_lock(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_SCIP_CONS.getCPtr(cons), locktype.swigValue(), nlockspos, nlocksneg) : SCIPJNIJNI.ObjConshdlr_scip_lockSwigExplicitObjConshdlr(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_SCIP_CONS.getCPtr(cons), locktype.swigValue(), nlockspos, nlocksneg)); + } + + public SCIP_Retcode scip_active(SWIGTYPE_p_SCIP scip, SWIGTYPE_p_SCIP_CONSHDLR conshdlr, SWIGTYPE_p_SCIP_CONS cons) { + return SCIP_Retcode.swigToEnum((getClass() == ObjConshdlr.class) ? SCIPJNIJNI.ObjConshdlr_scip_active(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_SCIP_CONS.getCPtr(cons)) : SCIPJNIJNI.ObjConshdlr_scip_activeSwigExplicitObjConshdlr(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_SCIP_CONS.getCPtr(cons))); + } + + public SCIP_Retcode scip_deactive(SWIGTYPE_p_SCIP scip, SWIGTYPE_p_SCIP_CONSHDLR conshdlr, SWIGTYPE_p_SCIP_CONS cons) { + return SCIP_Retcode.swigToEnum((getClass() == ObjConshdlr.class) ? SCIPJNIJNI.ObjConshdlr_scip_deactive(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_SCIP_CONS.getCPtr(cons)) : SCIPJNIJNI.ObjConshdlr_scip_deactiveSwigExplicitObjConshdlr(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_SCIP_CONS.getCPtr(cons))); + } + + public SCIP_Retcode scip_enable(SWIGTYPE_p_SCIP scip, SWIGTYPE_p_SCIP_CONSHDLR conshdlr, SWIGTYPE_p_SCIP_CONS cons) { + return SCIP_Retcode.swigToEnum((getClass() == ObjConshdlr.class) ? SCIPJNIJNI.ObjConshdlr_scip_enable(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_SCIP_CONS.getCPtr(cons)) : SCIPJNIJNI.ObjConshdlr_scip_enableSwigExplicitObjConshdlr(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_SCIP_CONS.getCPtr(cons))); + } + + public SCIP_Retcode scip_disable(SWIGTYPE_p_SCIP scip, SWIGTYPE_p_SCIP_CONSHDLR conshdlr, SWIGTYPE_p_SCIP_CONS cons) { + return SCIP_Retcode.swigToEnum((getClass() == ObjConshdlr.class) ? SCIPJNIJNI.ObjConshdlr_scip_disable(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_SCIP_CONS.getCPtr(cons)) : SCIPJNIJNI.ObjConshdlr_scip_disableSwigExplicitObjConshdlr(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_SCIP_CONS.getCPtr(cons))); + } + + public SCIP_Retcode scip_delvars(SWIGTYPE_p_SCIP scip, SWIGTYPE_p_SCIP_CONSHDLR conshdlr, SWIGTYPE_p_p_SCIP_CONS conss, int nconss) { + return SCIP_Retcode.swigToEnum((getClass() == ObjConshdlr.class) ? SCIPJNIJNI.ObjConshdlr_scip_delvars(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_p_SCIP_CONS.getCPtr(conss), nconss) : SCIPJNIJNI.ObjConshdlr_scip_delvarsSwigExplicitObjConshdlr(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_p_SCIP_CONS.getCPtr(conss), nconss)); + } + + public SCIP_Retcode scip_print(SWIGTYPE_p_SCIP scip, SWIGTYPE_p_SCIP_CONSHDLR conshdlr, SWIGTYPE_p_SCIP_CONS cons, SWIGTYPE_p_FILE file) { + return SCIP_Retcode.swigToEnum((getClass() == ObjConshdlr.class) ? SCIPJNIJNI.ObjConshdlr_scip_print(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_SCIP_CONS.getCPtr(cons), SWIGTYPE_p_FILE.getCPtr(file)) : SCIPJNIJNI.ObjConshdlr_scip_printSwigExplicitObjConshdlr(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_SCIP_CONS.getCPtr(cons), SWIGTYPE_p_FILE.getCPtr(file))); + } + + public SCIP_Retcode scip_copy(SWIGTYPE_p_SCIP scip, SWIGTYPE_p_p_SCIP_CONS cons, String name, SWIGTYPE_p_SCIP sourcescip, SWIGTYPE_p_SCIP_CONSHDLR sourceconshdlr, SWIGTYPE_p_SCIP_CONS sourcecons, SWIGTYPE_p_SCIP_HASHMAP varmap, SWIGTYPE_p_SCIP_HASHMAP consmap, long initial, long separate, long enforce, long check, long propagate, long local, long modifiable, long dynamic, long removable, long stickingatnode, long global, SWIGTYPE_p_unsigned_int valid) { + return SCIP_Retcode.swigToEnum((getClass() == ObjConshdlr.class) ? SCIPJNIJNI.ObjConshdlr_scip_copy(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_p_SCIP_CONS.getCPtr(cons), name, SWIGTYPE_p_SCIP.getCPtr(sourcescip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(sourceconshdlr), SWIGTYPE_p_SCIP_CONS.getCPtr(sourcecons), SWIGTYPE_p_SCIP_HASHMAP.getCPtr(varmap), SWIGTYPE_p_SCIP_HASHMAP.getCPtr(consmap), initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, stickingatnode, global, SWIGTYPE_p_unsigned_int.getCPtr(valid)) : SCIPJNIJNI.ObjConshdlr_scip_copySwigExplicitObjConshdlr(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_p_SCIP_CONS.getCPtr(cons), name, SWIGTYPE_p_SCIP.getCPtr(sourcescip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(sourceconshdlr), SWIGTYPE_p_SCIP_CONS.getCPtr(sourcecons), SWIGTYPE_p_SCIP_HASHMAP.getCPtr(varmap), SWIGTYPE_p_SCIP_HASHMAP.getCPtr(consmap), initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, stickingatnode, global, SWIGTYPE_p_unsigned_int.getCPtr(valid))); + } + + public SCIP_Retcode scip_parse(SWIGTYPE_p_SCIP scip, SWIGTYPE_p_SCIP_CONSHDLR conshdlr, SWIGTYPE_p_p_SCIP_CONS cons, String name, String str, long initial, long separate, long enforce, long check, long propagate, long local, long modifiable, long dynamic, long removable, long stickingatnode, SWIGTYPE_p_unsigned_int success) { + return SCIP_Retcode.swigToEnum((getClass() == ObjConshdlr.class) ? SCIPJNIJNI.ObjConshdlr_scip_parse(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_p_SCIP_CONS.getCPtr(cons), name, str, initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, stickingatnode, SWIGTYPE_p_unsigned_int.getCPtr(success)) : SCIPJNIJNI.ObjConshdlr_scip_parseSwigExplicitObjConshdlr(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_p_SCIP_CONS.getCPtr(cons), name, str, initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, stickingatnode, SWIGTYPE_p_unsigned_int.getCPtr(success))); + } + + public SCIP_Retcode scip_getvars(SWIGTYPE_p_SCIP scip, SWIGTYPE_p_SCIP_CONSHDLR conshdlr, SWIGTYPE_p_SCIP_CONS cons, SWIGTYPE_p_p_SCIP_VAR vars, int varssize, SWIGTYPE_p_unsigned_int success) { + return SCIP_Retcode.swigToEnum((getClass() == ObjConshdlr.class) ? SCIPJNIJNI.ObjConshdlr_scip_getvars(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_SCIP_CONS.getCPtr(cons), SWIGTYPE_p_p_SCIP_VAR.getCPtr(vars), varssize, SWIGTYPE_p_unsigned_int.getCPtr(success)) : SCIPJNIJNI.ObjConshdlr_scip_getvarsSwigExplicitObjConshdlr(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_SCIP_CONS.getCPtr(cons), SWIGTYPE_p_p_SCIP_VAR.getCPtr(vars), varssize, SWIGTYPE_p_unsigned_int.getCPtr(success))); + } + + public SCIP_Retcode scip_getnvars(SWIGTYPE_p_SCIP scip, SWIGTYPE_p_SCIP_CONSHDLR conshdlr, SWIGTYPE_p_SCIP_CONS cons, SWIGTYPE_p_int nvars, SWIGTYPE_p_unsigned_int success) { + return SCIP_Retcode.swigToEnum((getClass() == ObjConshdlr.class) ? SCIPJNIJNI.ObjConshdlr_scip_getnvars(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_SCIP_CONS.getCPtr(cons), SWIGTYPE_p_int.getCPtr(nvars), SWIGTYPE_p_unsigned_int.getCPtr(success)) : SCIPJNIJNI.ObjConshdlr_scip_getnvarsSwigExplicitObjConshdlr(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_SCIP_CONS.getCPtr(cons), SWIGTYPE_p_int.getCPtr(nvars), SWIGTYPE_p_unsigned_int.getCPtr(success))); + } + + public SCIP_Retcode scip_getdivebdchgs(SWIGTYPE_p_SCIP scip, SWIGTYPE_p_SCIP_CONSHDLR conshdlr, SWIGTYPE_p_SCIP_DIVESET diveset, SWIGTYPE_p_SCIP_SOL sol, SWIGTYPE_p_unsigned_int success, SWIGTYPE_p_unsigned_int infeasible) { + return SCIP_Retcode.swigToEnum((getClass() == ObjConshdlr.class) ? SCIPJNIJNI.ObjConshdlr_scip_getdivebdchgs(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_SCIP_DIVESET.getCPtr(diveset), SWIGTYPE_p_SCIP_SOL.getCPtr(sol), SWIGTYPE_p_unsigned_int.getCPtr(success), SWIGTYPE_p_unsigned_int.getCPtr(infeasible)) : SCIPJNIJNI.ObjConshdlr_scip_getdivebdchgsSwigExplicitObjConshdlr(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_SCIP_DIVESET.getCPtr(diveset), SWIGTYPE_p_SCIP_SOL.getCPtr(sol), SWIGTYPE_p_unsigned_int.getCPtr(success), SWIGTYPE_p_unsigned_int.getCPtr(infeasible))); + } + + public SCIP_Retcode scip_getpermsymgraph(SWIGTYPE_p_SCIP scip, SWIGTYPE_p_SCIP_CONSHDLR conshdlr, SWIGTYPE_p_SCIP_CONS cons, SWIGTYPE_p_SYM_GRAPH graph, SWIGTYPE_p_unsigned_int success) { + return SCIP_Retcode.swigToEnum((getClass() == ObjConshdlr.class) ? SCIPJNIJNI.ObjConshdlr_scip_getpermsymgraph(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_SCIP_CONS.getCPtr(cons), SWIGTYPE_p_SYM_GRAPH.getCPtr(graph), SWIGTYPE_p_unsigned_int.getCPtr(success)) : SCIPJNIJNI.ObjConshdlr_scip_getpermsymgraphSwigExplicitObjConshdlr(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_SCIP_CONS.getCPtr(cons), SWIGTYPE_p_SYM_GRAPH.getCPtr(graph), SWIGTYPE_p_unsigned_int.getCPtr(success))); + } + + public SCIP_Retcode scip_getsignedpermsymgraph(SWIGTYPE_p_SCIP scip, SWIGTYPE_p_SCIP_CONSHDLR conshdlr, SWIGTYPE_p_SCIP_CONS cons, SWIGTYPE_p_SYM_GRAPH graph, SWIGTYPE_p_unsigned_int success) { + return SCIP_Retcode.swigToEnum((getClass() == ObjConshdlr.class) ? SCIPJNIJNI.ObjConshdlr_scip_getsignedpermsymgraph(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_SCIP_CONS.getCPtr(cons), SWIGTYPE_p_SYM_GRAPH.getCPtr(graph), SWIGTYPE_p_unsigned_int.getCPtr(success)) : SCIPJNIJNI.ObjConshdlr_scip_getsignedpermsymgraphSwigExplicitObjConshdlr(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr), SWIGTYPE_p_SCIP_CONS.getCPtr(cons), SWIGTYPE_p_SYM_GRAPH.getCPtr(graph), SWIGTYPE_p_unsigned_int.getCPtr(success))); + } + +} diff --git a/java/jscip/ObjEventhdlr.java b/java/jscip/ObjEventhdlr.java new file mode 100644 index 0000000..ce7ce26 --- /dev/null +++ b/java/jscip/ObjEventhdlr.java @@ -0,0 +1,112 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package jscip; + +public class ObjEventhdlr { + private transient long swigCPtr; + protected transient boolean swigCMemOwn; + + protected ObjEventhdlr(long cPtr, boolean cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = cPtr; + } + + protected static long getCPtr(ObjEventhdlr obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + @SuppressWarnings("deprecation") + protected void finalize() { + delete(); + } + + public synchronized void delete() { + if (swigCPtr != 0) { + if (swigCMemOwn) { + swigCMemOwn = false; + SCIPJNIJNI.delete_ObjEventhdlr(swigCPtr); + } + swigCPtr = 0; + } + } + + protected void swigDirectorDisconnect() { + swigCMemOwn = false; + delete(); + } + + public void swigReleaseOwnership() { + swigCMemOwn = false; + SCIPJNIJNI.ObjEventhdlr_change_ownership(this, swigCPtr, false); + } + + public void swigTakeOwnership() { + swigCMemOwn = true; + SCIPJNIJNI.ObjEventhdlr_change_ownership(this, swigCPtr, true); + } + + public void setScip_(SWIGTYPE_p_SCIP value) { + SCIPJNIJNI.ObjEventhdlr_scip__set(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(value)); + } + + public SWIGTYPE_p_SCIP getScip_() { + long cPtr = SCIPJNIJNI.ObjEventhdlr_scip__get(swigCPtr, this); + return (cPtr == 0) ? null : new SWIGTYPE_p_SCIP(cPtr, false); + } + + public void setScip_name_(String value) { + SCIPJNIJNI.ObjEventhdlr_scip_name__set(swigCPtr, this, value); + } + + public String getScip_name_() { + return SCIPJNIJNI.ObjEventhdlr_scip_name__get(swigCPtr, this); + } + + public void setScip_desc_(String value) { + SCIPJNIJNI.ObjEventhdlr_scip_desc__set(swigCPtr, this, value); + } + + public String getScip_desc_() { + return SCIPJNIJNI.ObjEventhdlr_scip_desc__get(swigCPtr, this); + } + + public ObjEventhdlr(SWIGTYPE_p_SCIP scip, String name, String desc) { + this(SCIPJNIJNI.new_ObjEventhdlr(SWIGTYPE_p_SCIP.getCPtr(scip), name, desc), true); + SCIPJNIJNI.ObjEventhdlr_director_connect(this, swigCPtr, true, true); + } + + public SCIP_Retcode scip_free(SWIGTYPE_p_SCIP scip, SWIGTYPE_p_SCIP_EVENTHDLR eventhdlr) { + return SCIP_Retcode.swigToEnum((getClass() == ObjEventhdlr.class) ? SCIPJNIJNI.ObjEventhdlr_scip_free(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_EVENTHDLR.getCPtr(eventhdlr)) : SCIPJNIJNI.ObjEventhdlr_scip_freeSwigExplicitObjEventhdlr(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_EVENTHDLR.getCPtr(eventhdlr))); + } + + public SCIP_Retcode scip_init(SWIGTYPE_p_SCIP scip, SWIGTYPE_p_SCIP_EVENTHDLR eventhdlr) { + return SCIP_Retcode.swigToEnum((getClass() == ObjEventhdlr.class) ? SCIPJNIJNI.ObjEventhdlr_scip_init(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_EVENTHDLR.getCPtr(eventhdlr)) : SCIPJNIJNI.ObjEventhdlr_scip_initSwigExplicitObjEventhdlr(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_EVENTHDLR.getCPtr(eventhdlr))); + } + + public SCIP_Retcode scip_exit(SWIGTYPE_p_SCIP scip, SWIGTYPE_p_SCIP_EVENTHDLR eventhdlr) { + return SCIP_Retcode.swigToEnum((getClass() == ObjEventhdlr.class) ? SCIPJNIJNI.ObjEventhdlr_scip_exit(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_EVENTHDLR.getCPtr(eventhdlr)) : SCIPJNIJNI.ObjEventhdlr_scip_exitSwigExplicitObjEventhdlr(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_EVENTHDLR.getCPtr(eventhdlr))); + } + + public SCIP_Retcode scip_initsol(SWIGTYPE_p_SCIP scip, SWIGTYPE_p_SCIP_EVENTHDLR eventhdlr) { + return SCIP_Retcode.swigToEnum((getClass() == ObjEventhdlr.class) ? SCIPJNIJNI.ObjEventhdlr_scip_initsol(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_EVENTHDLR.getCPtr(eventhdlr)) : SCIPJNIJNI.ObjEventhdlr_scip_initsolSwigExplicitObjEventhdlr(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_EVENTHDLR.getCPtr(eventhdlr))); + } + + public SCIP_Retcode scip_exitsol(SWIGTYPE_p_SCIP scip, SWIGTYPE_p_SCIP_EVENTHDLR eventhdlr) { + return SCIP_Retcode.swigToEnum((getClass() == ObjEventhdlr.class) ? SCIPJNIJNI.ObjEventhdlr_scip_exitsol(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_EVENTHDLR.getCPtr(eventhdlr)) : SCIPJNIJNI.ObjEventhdlr_scip_exitsolSwigExplicitObjEventhdlr(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_EVENTHDLR.getCPtr(eventhdlr))); + } + + public SCIP_Retcode scip_delete(SWIGTYPE_p_SCIP scip, SWIGTYPE_p_SCIP_EVENTHDLR eventhdlr, SWIGTYPE_p_p_SCIP_EVENTDATA eventdata) { + return SCIP_Retcode.swigToEnum((getClass() == ObjEventhdlr.class) ? SCIPJNIJNI.ObjEventhdlr_scip_delete(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_EVENTHDLR.getCPtr(eventhdlr), SWIGTYPE_p_p_SCIP_EVENTDATA.getCPtr(eventdata)) : SCIPJNIJNI.ObjEventhdlr_scip_deleteSwigExplicitObjEventhdlr(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_EVENTHDLR.getCPtr(eventhdlr), SWIGTYPE_p_p_SCIP_EVENTDATA.getCPtr(eventdata))); + } + + public SCIP_Retcode scip_exec(SWIGTYPE_p_SCIP scip, SWIGTYPE_p_SCIP_EVENTHDLR eventhdlr, SCIP_Event event, SWIGTYPE_p_SCIP_EVENTDATA eventdata) { + return SCIP_Retcode.swigToEnum((getClass() == ObjEventhdlr.class) ? SCIPJNIJNI.ObjEventhdlr_scip_exec(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_EVENTHDLR.getCPtr(eventhdlr), SCIP_Event.getCPtr(event), event, SWIGTYPE_p_SCIP_EVENTDATA.getCPtr(eventdata)) : SCIPJNIJNI.ObjEventhdlr_scip_execSwigExplicitObjEventhdlr(swigCPtr, this, SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_EVENTHDLR.getCPtr(eventhdlr), SCIP_Event.getCPtr(event), event, SWIGTYPE_p_SCIP_EVENTDATA.getCPtr(eventdata))); + } + +} diff --git a/java/jscip/ResultHolder.java b/java/jscip/ResultHolder.java new file mode 100644 index 0000000..06ddbde --- /dev/null +++ b/java/jscip/ResultHolder.java @@ -0,0 +1,21 @@ +package jscip; + +import java.util.Objects; + +public class ResultHolder { + + private SCIP_Result value = SCIP_Result.SCIP_DIDNOTRUN; + + public void setValue(SCIP_Result value) { + this.value = Objects.requireNonNull(value, "result"); + } + + public boolean isSet() { + return value != SCIP_Result.SCIP_DIDNOTRUN; + } + + public SCIP_Result getValue() { + return value; + } + +} diff --git a/java/jscip/SCIPJNI.java b/java/jscip/SCIPJNI.java index 59fb675..2fa9795 100644 --- a/java/jscip/SCIPJNI.java +++ b/java/jscip/SCIPJNI.java @@ -789,4 +789,117 @@ public static SWIGTYPE_p_SCIP_Messagehdlr createObjMessagehdlr(ObjMessagehdlr ob return (cPtr == 0) ? null : new SWIGTYPE_p_SCIP_Messagehdlr(cPtr, false); } + public static SCIP_EventVarAdded getEventDataVarAdde(SCIP_Event event) { + return new SCIP_EventVarAdded(SCIPJNIJNI.getEventDataVarAdde(SCIP_Event.getCPtr(event), event), true); + } + + public static SCIP_EventVarDeleted getEventDataVarDeleted(SCIP_Event event) { + return new SCIP_EventVarDeleted(SCIPJNIJNI.getEventDataVarDeleted(SCIP_Event.getCPtr(event), event), true); + } + + public static SCIP_EventVarFixed getEventDataVarFixed(SCIP_Event event) { + return new SCIP_EventVarFixed(SCIPJNIJNI.getEventDataVarFixed(SCIP_Event.getCPtr(event), event), true); + } + + public static SCIP_EventVarUnlocked getEventDataVarUnlocked(SCIP_Event event) { + return new SCIP_EventVarUnlocked(SCIPJNIJNI.getEventDataVarUnlocked(SCIP_Event.getCPtr(event), event), true); + } + + public static SCIP_EventObjChg getEventDataObjChg(SCIP_Event event) { + return new SCIP_EventObjChg(SCIPJNIJNI.getEventDataObjChg(SCIP_Event.getCPtr(event), event), true); + } + + public static SCIP_EventBdChg getEventDataBdChg(SCIP_Event event) { + return new SCIP_EventBdChg(SCIPJNIJNI.getEventDataBdChg(SCIP_Event.getCPtr(event), event), true); + } + + public static SCIP_EventHole getEventDataHole(SCIP_Event event) { + return new SCIP_EventHole(SCIPJNIJNI.getEventDataHole(SCIP_Event.getCPtr(event), event), true); + } + + public static SCIP_EventImplAdd getEventDataImplAdd(SCIP_Event event) { + return new SCIP_EventImplAdd(SCIPJNIJNI.getEventDataImplAdd(SCIP_Event.getCPtr(event), event), true); + } + + public static SCIP_EventTypeChg getEventDataTypeChg(SCIP_Event event) { + return new SCIP_EventTypeChg(SCIPJNIJNI.getEventDataTypeChg(SCIP_Event.getCPtr(event), event), true); + } + + public static SCIP_EventRowAddedSepa getEventDataRowAddedSepa(SCIP_Event event) { + return new SCIP_EventRowAddedSepa(SCIPJNIJNI.getEventDataRowAddedSepa(SCIP_Event.getCPtr(event), event), true); + } + + public static SCIP_EventRowDeletedSepa getEventDataRowDeletedSepa(SCIP_Event event) { + return new SCIP_EventRowDeletedSepa(SCIPJNIJNI.getEventDataRowDeletedSepa(SCIP_Event.getCPtr(event), event), true); + } + + public static SCIP_EventRowAddedLP getEventDataRowAddedLp(SCIP_Event event) { + return new SCIP_EventRowAddedLP(SCIPJNIJNI.getEventDataRowAddedLp(SCIP_Event.getCPtr(event), event), true); + } + + public static SCIP_EventRowDeletedLP getEventDataRowDeletedLp(SCIP_Event event) { + return new SCIP_EventRowDeletedLP(SCIPJNIJNI.getEventDataRowDeletedLp(SCIP_Event.getCPtr(event), event), true); + } + + public static SCIP_EventRowCoefChanged getEventDataRowCoefChanged(SCIP_Event event) { + return new SCIP_EventRowCoefChanged(SCIPJNIJNI.getEventDataRowCoefChanged(SCIP_Event.getCPtr(event), event), true); + } + + public static SCIP_EventRowConstChanged getEventDataRowConstChanged(SCIP_Event event) { + return new SCIP_EventRowConstChanged(SCIPJNIJNI.getEventDataRowConstChanged(SCIP_Event.getCPtr(event), event), true); + } + + public static SCIP_EventRowSideChanged getEventDataRowSideChanged(SCIP_Event event) { + return new SCIP_EventRowSideChanged(SCIPJNIJNI.getEventDataRowSideChanged(SCIP_Event.getCPtr(event), event), true); + } + + public static SWIGTYPE_p_SCIP_SOL getEventDataSolution(SCIP_Event event) { + long cPtr = SCIPJNIJNI.getEventDataSolution(SCIP_Event.getCPtr(event), event); + return (cPtr == 0) ? null : new SWIGTYPE_p_SCIP_SOL(cPtr, false); + } + + public static SWIGTYPE_p_SCIP_NODE getEventDataNode(SCIP_Event event) { + long cPtr = SCIPJNIJNI.getEventDataNode(SCIP_Event.getCPtr(event), event); + return (cPtr == 0) ? null : new SWIGTYPE_p_SCIP_NODE(cPtr, false); + } + + public static SCIP_Retcode SCIPincludeObjEventhdlr(SWIGTYPE_p_SCIP scip, ObjEventhdlr objeventhdlr, long deleteobject) { + return SCIP_Retcode.swigToEnum(SCIPJNIJNI.SCIPincludeObjEventhdlr(SWIGTYPE_p_SCIP.getCPtr(scip), ObjEventhdlr.getCPtr(objeventhdlr), objeventhdlr, deleteobject)); + } + + public static ObjEventhdlr SCIPfindObjEventhdlr(SWIGTYPE_p_SCIP scip, String name) { + long cPtr = SCIPJNIJNI.SCIPfindObjEventhdlr(SWIGTYPE_p_SCIP.getCPtr(scip), name); + return (cPtr == 0) ? null : new ObjEventhdlr(cPtr, false); + } + + public static SCIP_Retcode SCIPcatchEvent(SWIGTYPE_p_SCIP scip, long eventtype, SWIGTYPE_p_SCIP_EVENTHDLR eventhdlr, SWIGTYPE_p_SCIP_EVENTDATA eventdata, SWIGTYPE_p_int filterpos) { + return SCIP_Retcode.swigToEnum(SCIPJNIJNI.SCIPcatchEvent(SWIGTYPE_p_SCIP.getCPtr(scip), eventtype, SWIGTYPE_p_SCIP_EVENTHDLR.getCPtr(eventhdlr), SWIGTYPE_p_SCIP_EVENTDATA.getCPtr(eventdata), SWIGTYPE_p_int.getCPtr(filterpos))); + } + + public static SCIP_Retcode SCIPincludeObjConshdlr(SWIGTYPE_p_SCIP scip, ObjConshdlr objconshdlr, long deleteobject) { + return SCIP_Retcode.swigToEnum(SCIPJNIJNI.SCIPincludeObjConshdlr(SWIGTYPE_p_SCIP.getCPtr(scip), ObjConshdlr.getCPtr(objconshdlr), objconshdlr, deleteobject)); + } + + public static ObjConshdlr SCIPfindObjConshdlr(SWIGTYPE_p_SCIP scip, String name) { + long cPtr = SCIPJNIJNI.SCIPfindObjConshdlr(SWIGTYPE_p_SCIP.getCPtr(scip), name); + return (cPtr == 0) ? null : new ObjConshdlr(cPtr, false); + } + + public static ObjConshdlr SCIPgetObjConshdlr(SWIGTYPE_p_SCIP scip, SWIGTYPE_p_SCIP_CONSHDLR conshdlr) { + long cPtr = SCIPJNIJNI.SCIPgetObjConshdlr(SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONSHDLR.getCPtr(conshdlr)); + return (cPtr == 0) ? null : new ObjConshdlr(cPtr, false); + } + + public static SCIP_Retcode SCIPaddVarLocksType(SWIGTYPE_p_SCIP scip, SWIGTYPE_p_SCIP_VAR var, SCIP_LockType locktype, int nlocksdown, int nlocksup) { + return SCIP_Retcode.swigToEnum(SCIPJNIJNI.SCIPaddVarLocksType(SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_VAR.getCPtr(var), locktype.swigValue(), nlocksdown, nlocksup)); + } + + public static SCIP_Retcode SCIPaddConsLocksType(SWIGTYPE_p_SCIP scip, SWIGTYPE_p_SCIP_CONS cons, SCIP_LockType locktype, int nlockspos, int nlocksneg) { + return SCIP_Retcode.swigToEnum(SCIPJNIJNI.SCIPaddConsLocksType(SWIGTYPE_p_SCIP.getCPtr(scip), SWIGTYPE_p_SCIP_CONS.getCPtr(cons), locktype.swigValue(), nlockspos, nlocksneg)); + } + + public static void setResult(SWIGTYPE_p_SCIP_Result resultPtr, SCIP_Result scipResult) { + SCIPJNIJNI.setResult(SWIGTYPE_p_SCIP_Result.getCPtr(resultPtr), scipResult.swigValue()); + } + } diff --git a/java/jscip/SCIPJNIJNI.java b/java/jscip/SCIPJNIJNI.java index 3529c10..7ed25ca 100644 --- a/java/jscip/SCIPJNIJNI.java +++ b/java/jscip/SCIPJNIJNI.java @@ -282,6 +282,265 @@ public class SCIPJNIJNI { public final static native long createConsBasicXor(long jarg1, String jarg2, long jarg3, int jarg4, long jarg5); public final static native void releaseCons(long jarg1, long jarg2); public final static native long createObjMessagehdlr(long jarg1, ObjMessagehdlr jarg1_, long jarg2); + public final static native void SCIP_EventVarAdded_var_set(long jarg1, SCIP_EventVarAdded jarg1_, long jarg2); + public final static native long SCIP_EventVarAdded_var_get(long jarg1, SCIP_EventVarAdded jarg1_); + public final static native long new_SCIP_EventVarAdded(); + public final static native void delete_SCIP_EventVarAdded(long jarg1); + public final static native void SCIP_EventVarDeleted_var_set(long jarg1, SCIP_EventVarDeleted jarg1_, long jarg2); + public final static native long SCIP_EventVarDeleted_var_get(long jarg1, SCIP_EventVarDeleted jarg1_); + public final static native long new_SCIP_EventVarDeleted(); + public final static native void delete_SCIP_EventVarDeleted(long jarg1); + public final static native void SCIP_EventVarFixed_var_set(long jarg1, SCIP_EventVarFixed jarg1_, long jarg2); + public final static native long SCIP_EventVarFixed_var_get(long jarg1, SCIP_EventVarFixed jarg1_); + public final static native long new_SCIP_EventVarFixed(); + public final static native void delete_SCIP_EventVarFixed(long jarg1); + public final static native void SCIP_EventVarUnlocked_var_set(long jarg1, SCIP_EventVarUnlocked jarg1_, long jarg2); + public final static native long SCIP_EventVarUnlocked_var_get(long jarg1, SCIP_EventVarUnlocked jarg1_); + public final static native long new_SCIP_EventVarUnlocked(); + public final static native void delete_SCIP_EventVarUnlocked(long jarg1); + public final static native void SCIP_EventObjChg_oldobj_set(long jarg1, SCIP_EventObjChg jarg1_, double jarg2); + public final static native double SCIP_EventObjChg_oldobj_get(long jarg1, SCIP_EventObjChg jarg1_); + public final static native void SCIP_EventObjChg_newobj_set(long jarg1, SCIP_EventObjChg jarg1_, double jarg2); + public final static native double SCIP_EventObjChg_newobj_get(long jarg1, SCIP_EventObjChg jarg1_); + public final static native void SCIP_EventObjChg_var_set(long jarg1, SCIP_EventObjChg jarg1_, long jarg2); + public final static native long SCIP_EventObjChg_var_get(long jarg1, SCIP_EventObjChg jarg1_); + public final static native long new_SCIP_EventObjChg(); + public final static native void delete_SCIP_EventObjChg(long jarg1); + public final static native void SCIP_EventBdChg_oldbound_set(long jarg1, SCIP_EventBdChg jarg1_, double jarg2); + public final static native double SCIP_EventBdChg_oldbound_get(long jarg1, SCIP_EventBdChg jarg1_); + public final static native void SCIP_EventBdChg_newbound_set(long jarg1, SCIP_EventBdChg jarg1_, double jarg2); + public final static native double SCIP_EventBdChg_newbound_get(long jarg1, SCIP_EventBdChg jarg1_); + public final static native void SCIP_EventBdChg_var_set(long jarg1, SCIP_EventBdChg jarg1_, long jarg2); + public final static native long SCIP_EventBdChg_var_get(long jarg1, SCIP_EventBdChg jarg1_); + public final static native long new_SCIP_EventBdChg(); + public final static native void delete_SCIP_EventBdChg(long jarg1); + public final static native void SCIP_EventHole_left_set(long jarg1, SCIP_EventHole jarg1_, double jarg2); + public final static native double SCIP_EventHole_left_get(long jarg1, SCIP_EventHole jarg1_); + public final static native void SCIP_EventHole_right_set(long jarg1, SCIP_EventHole jarg1_, double jarg2); + public final static native double SCIP_EventHole_right_get(long jarg1, SCIP_EventHole jarg1_); + public final static native void SCIP_EventHole_var_set(long jarg1, SCIP_EventHole jarg1_, long jarg2); + public final static native long SCIP_EventHole_var_get(long jarg1, SCIP_EventHole jarg1_); + public final static native long new_SCIP_EventHole(); + public final static native void delete_SCIP_EventHole(long jarg1); + public final static native void SCIP_EventImplAdd_var_set(long jarg1, SCIP_EventImplAdd jarg1_, long jarg2); + public final static native long SCIP_EventImplAdd_var_get(long jarg1, SCIP_EventImplAdd jarg1_); + public final static native long new_SCIP_EventImplAdd(); + public final static native void delete_SCIP_EventImplAdd(long jarg1); + public final static native void SCIP_EventTypeChg_oldtype_set(long jarg1, SCIP_EventTypeChg jarg1_, int jarg2); + public final static native int SCIP_EventTypeChg_oldtype_get(long jarg1, SCIP_EventTypeChg jarg1_); + public final static native void SCIP_EventTypeChg_newtype_set(long jarg1, SCIP_EventTypeChg jarg1_, int jarg2); + public final static native int SCIP_EventTypeChg_newtype_get(long jarg1, SCIP_EventTypeChg jarg1_); + public final static native void SCIP_EventTypeChg_var_set(long jarg1, SCIP_EventTypeChg jarg1_, long jarg2); + public final static native long SCIP_EventTypeChg_var_get(long jarg1, SCIP_EventTypeChg jarg1_); + public final static native long new_SCIP_EventTypeChg(); + public final static native void delete_SCIP_EventTypeChg(long jarg1); + public final static native void SCIP_EventRowAddedSepa_row_set(long jarg1, SCIP_EventRowAddedSepa jarg1_, long jarg2); + public final static native long SCIP_EventRowAddedSepa_row_get(long jarg1, SCIP_EventRowAddedSepa jarg1_); + public final static native long new_SCIP_EventRowAddedSepa(); + public final static native void delete_SCIP_EventRowAddedSepa(long jarg1); + public final static native void SCIP_EventRowDeletedSepa_row_set(long jarg1, SCIP_EventRowDeletedSepa jarg1_, long jarg2); + public final static native long SCIP_EventRowDeletedSepa_row_get(long jarg1, SCIP_EventRowDeletedSepa jarg1_); + public final static native long new_SCIP_EventRowDeletedSepa(); + public final static native void delete_SCIP_EventRowDeletedSepa(long jarg1); + public final static native void SCIP_EventRowAddedLP_row_set(long jarg1, SCIP_EventRowAddedLP jarg1_, long jarg2); + public final static native long SCIP_EventRowAddedLP_row_get(long jarg1, SCIP_EventRowAddedLP jarg1_); + public final static native long new_SCIP_EventRowAddedLP(); + public final static native void delete_SCIP_EventRowAddedLP(long jarg1); + public final static native void SCIP_EventRowDeletedLP_row_set(long jarg1, SCIP_EventRowDeletedLP jarg1_, long jarg2); + public final static native long SCIP_EventRowDeletedLP_row_get(long jarg1, SCIP_EventRowDeletedLP jarg1_); + public final static native long new_SCIP_EventRowDeletedLP(); + public final static native void delete_SCIP_EventRowDeletedLP(long jarg1); + public final static native void SCIP_EventRowCoefChanged_row_set(long jarg1, SCIP_EventRowCoefChanged jarg1_, long jarg2); + public final static native long SCIP_EventRowCoefChanged_row_get(long jarg1, SCIP_EventRowCoefChanged jarg1_); + public final static native void SCIP_EventRowCoefChanged_col_set(long jarg1, SCIP_EventRowCoefChanged jarg1_, long jarg2); + public final static native long SCIP_EventRowCoefChanged_col_get(long jarg1, SCIP_EventRowCoefChanged jarg1_); + public final static native void SCIP_EventRowCoefChanged_oldval_set(long jarg1, SCIP_EventRowCoefChanged jarg1_, double jarg2); + public final static native double SCIP_EventRowCoefChanged_oldval_get(long jarg1, SCIP_EventRowCoefChanged jarg1_); + public final static native void SCIP_EventRowCoefChanged_newval_set(long jarg1, SCIP_EventRowCoefChanged jarg1_, double jarg2); + public final static native double SCIP_EventRowCoefChanged_newval_get(long jarg1, SCIP_EventRowCoefChanged jarg1_); + public final static native long new_SCIP_EventRowCoefChanged(); + public final static native void delete_SCIP_EventRowCoefChanged(long jarg1); + public final static native void SCIP_EventRowConstChanged_row_set(long jarg1, SCIP_EventRowConstChanged jarg1_, long jarg2); + public final static native long SCIP_EventRowConstChanged_row_get(long jarg1, SCIP_EventRowConstChanged jarg1_); + public final static native void SCIP_EventRowConstChanged_oldval_set(long jarg1, SCIP_EventRowConstChanged jarg1_, double jarg2); + public final static native double SCIP_EventRowConstChanged_oldval_get(long jarg1, SCIP_EventRowConstChanged jarg1_); + public final static native void SCIP_EventRowConstChanged_newval_set(long jarg1, SCIP_EventRowConstChanged jarg1_, double jarg2); + public final static native double SCIP_EventRowConstChanged_newval_get(long jarg1, SCIP_EventRowConstChanged jarg1_); + public final static native long new_SCIP_EventRowConstChanged(); + public final static native void delete_SCIP_EventRowConstChanged(long jarg1); + public final static native void SCIP_EventRowSideChanged_row_set(long jarg1, SCIP_EventRowSideChanged jarg1_, long jarg2); + public final static native long SCIP_EventRowSideChanged_row_get(long jarg1, SCIP_EventRowSideChanged jarg1_); + public final static native void SCIP_EventRowSideChanged_side_set(long jarg1, SCIP_EventRowSideChanged jarg1_, long jarg2); + public final static native long SCIP_EventRowSideChanged_side_get(long jarg1, SCIP_EventRowSideChanged jarg1_); + public final static native void SCIP_EventRowSideChanged_oldval_set(long jarg1, SCIP_EventRowSideChanged jarg1_, double jarg2); + public final static native double SCIP_EventRowSideChanged_oldval_get(long jarg1, SCIP_EventRowSideChanged jarg1_); + public final static native void SCIP_EventRowSideChanged_newval_set(long jarg1, SCIP_EventRowSideChanged jarg1_, double jarg2); + public final static native double SCIP_EventRowSideChanged_newval_get(long jarg1, SCIP_EventRowSideChanged jarg1_); + public final static native long new_SCIP_EventRowSideChanged(); + public final static native void delete_SCIP_EventRowSideChanged(long jarg1); + public final static native void SCIP_Event_eventtype_set(long jarg1, SCIP_Event jarg1_, long jarg2); + public final static native long SCIP_Event_eventtype_get(long jarg1, SCIP_Event jarg1_); + public final static native long new_SCIP_Event(); + public final static native void delete_SCIP_Event(long jarg1); + public final static native long getEventDataVarAdde(long jarg1, SCIP_Event jarg1_); + public final static native long getEventDataVarDeleted(long jarg1, SCIP_Event jarg1_); + public final static native long getEventDataVarFixed(long jarg1, SCIP_Event jarg1_); + public final static native long getEventDataVarUnlocked(long jarg1, SCIP_Event jarg1_); + public final static native long getEventDataObjChg(long jarg1, SCIP_Event jarg1_); + public final static native long getEventDataBdChg(long jarg1, SCIP_Event jarg1_); + public final static native long getEventDataHole(long jarg1, SCIP_Event jarg1_); + public final static native long getEventDataImplAdd(long jarg1, SCIP_Event jarg1_); + public final static native long getEventDataTypeChg(long jarg1, SCIP_Event jarg1_); + public final static native long getEventDataRowAddedSepa(long jarg1, SCIP_Event jarg1_); + public final static native long getEventDataRowDeletedSepa(long jarg1, SCIP_Event jarg1_); + public final static native long getEventDataRowAddedLp(long jarg1, SCIP_Event jarg1_); + public final static native long getEventDataRowDeletedLp(long jarg1, SCIP_Event jarg1_); + public final static native long getEventDataRowCoefChanged(long jarg1, SCIP_Event jarg1_); + public final static native long getEventDataRowConstChanged(long jarg1, SCIP_Event jarg1_); + public final static native long getEventDataRowSideChanged(long jarg1, SCIP_Event jarg1_); + public final static native long getEventDataSolution(long jarg1, SCIP_Event jarg1_); + public final static native long getEventDataNode(long jarg1, SCIP_Event jarg1_); + public final static native void ObjEventhdlr_scip__set(long jarg1, ObjEventhdlr jarg1_, long jarg2); + public final static native long ObjEventhdlr_scip__get(long jarg1, ObjEventhdlr jarg1_); + public final static native void ObjEventhdlr_scip_name__set(long jarg1, ObjEventhdlr jarg1_, String jarg2); + public final static native String ObjEventhdlr_scip_name__get(long jarg1, ObjEventhdlr jarg1_); + public final static native void ObjEventhdlr_scip_desc__set(long jarg1, ObjEventhdlr jarg1_, String jarg2); + public final static native String ObjEventhdlr_scip_desc__get(long jarg1, ObjEventhdlr jarg1_); + public final static native long new_ObjEventhdlr(long jarg1, String jarg2, String jarg3); + public final static native void delete_ObjEventhdlr(long jarg1); + public final static native int ObjEventhdlr_scip_free(long jarg1, ObjEventhdlr jarg1_, long jarg2, long jarg3); + public final static native int ObjEventhdlr_scip_freeSwigExplicitObjEventhdlr(long jarg1, ObjEventhdlr jarg1_, long jarg2, long jarg3); + public final static native int ObjEventhdlr_scip_init(long jarg1, ObjEventhdlr jarg1_, long jarg2, long jarg3); + public final static native int ObjEventhdlr_scip_initSwigExplicitObjEventhdlr(long jarg1, ObjEventhdlr jarg1_, long jarg2, long jarg3); + public final static native int ObjEventhdlr_scip_exit(long jarg1, ObjEventhdlr jarg1_, long jarg2, long jarg3); + public final static native int ObjEventhdlr_scip_exitSwigExplicitObjEventhdlr(long jarg1, ObjEventhdlr jarg1_, long jarg2, long jarg3); + public final static native int ObjEventhdlr_scip_initsol(long jarg1, ObjEventhdlr jarg1_, long jarg2, long jarg3); + public final static native int ObjEventhdlr_scip_initsolSwigExplicitObjEventhdlr(long jarg1, ObjEventhdlr jarg1_, long jarg2, long jarg3); + public final static native int ObjEventhdlr_scip_exitsol(long jarg1, ObjEventhdlr jarg1_, long jarg2, long jarg3); + public final static native int ObjEventhdlr_scip_exitsolSwigExplicitObjEventhdlr(long jarg1, ObjEventhdlr jarg1_, long jarg2, long jarg3); + public final static native int ObjEventhdlr_scip_delete(long jarg1, ObjEventhdlr jarg1_, long jarg2, long jarg3, long jarg4); + public final static native int ObjEventhdlr_scip_deleteSwigExplicitObjEventhdlr(long jarg1, ObjEventhdlr jarg1_, long jarg2, long jarg3, long jarg4); + public final static native int ObjEventhdlr_scip_exec(long jarg1, ObjEventhdlr jarg1_, long jarg2, long jarg3, long jarg4, SCIP_Event jarg4_, long jarg5); + public final static native int ObjEventhdlr_scip_execSwigExplicitObjEventhdlr(long jarg1, ObjEventhdlr jarg1_, long jarg2, long jarg3, long jarg4, SCIP_Event jarg4_, long jarg5); + public final static native void ObjEventhdlr_director_connect(ObjEventhdlr obj, long cptr, boolean mem_own, boolean weak_global); + public final static native void ObjEventhdlr_change_ownership(ObjEventhdlr obj, long cptr, boolean take_or_release); + public final static native int SCIPincludeObjEventhdlr(long jarg1, long jarg2, ObjEventhdlr jarg2_, long jarg3); + public final static native long SCIPfindObjEventhdlr(long jarg1, String jarg2); + public final static native int SCIPcatchEvent(long jarg1, long jarg2, long jarg3, long jarg4, long jarg5); + public final static native int SCIP_DIDNOTRUN_get(); + public final static native int SCIP_DELAYED_get(); + public final static native int SCIP_DIDNOTFIND_get(); + public final static native int SCIP_FEASIBLE_get(); + public final static native int SCIP_INFEASIBLE_get(); + public final static native int SCIP_UNBOUNDED_get(); + public final static native int SCIP_CUTOFF_get(); + public final static native int SCIP_SEPARATED_get(); + public final static native int SCIP_NEWROUND_get(); + public final static native int SCIP_REDUCEDDOM_get(); + public final static native int SCIP_CONSADDED_get(); + public final static native int SCIP_CONSCHANGED_get(); + public final static native int SCIP_BRANCHED_get(); + public final static native int SCIP_SOLVELP_get(); + public final static native int SCIP_FOUNDSOL_get(); + public final static native int SCIP_SUSPENDED_get(); + public final static native int SCIP_SUCCESS_get(); + public final static native int SCIP_DELAYNODE_get(); + public final static native int SCIP_LOCKTYPE_MODEL_get(); + public final static native int SCIP_LOCKTYPE_CONFLICT_get(); + public final static native void ObjConshdlr_scip__set(long jarg1, ObjConshdlr jarg1_, long jarg2); + public final static native long ObjConshdlr_scip__get(long jarg1, ObjConshdlr jarg1_); + public final static native void ObjConshdlr_scip_name__set(long jarg1, ObjConshdlr jarg1_, String jarg2); + public final static native String ObjConshdlr_scip_name__get(long jarg1, ObjConshdlr jarg1_); + public final static native void ObjConshdlr_scip_desc__set(long jarg1, ObjConshdlr jarg1_, String jarg2); + public final static native String ObjConshdlr_scip_desc__get(long jarg1, ObjConshdlr jarg1_); + public final static native int ObjConshdlr_scip_sepapriority__get(long jarg1, ObjConshdlr jarg1_); + public final static native int ObjConshdlr_scip_enfopriority__get(long jarg1, ObjConshdlr jarg1_); + public final static native int ObjConshdlr_scip_checkpriority__get(long jarg1, ObjConshdlr jarg1_); + public final static native int ObjConshdlr_scip_sepafreq__get(long jarg1, ObjConshdlr jarg1_); + public final static native int ObjConshdlr_scip_propfreq__get(long jarg1, ObjConshdlr jarg1_); + public final static native int ObjConshdlr_scip_eagerfreq__get(long jarg1, ObjConshdlr jarg1_); + public final static native int ObjConshdlr_scip_maxprerounds__get(long jarg1, ObjConshdlr jarg1_); + public final static native long ObjConshdlr_scip_delaysepa__get(long jarg1, ObjConshdlr jarg1_); + public final static native long ObjConshdlr_scip_delayprop__get(long jarg1, ObjConshdlr jarg1_); + public final static native long ObjConshdlr_scip_needscons__get(long jarg1, ObjConshdlr jarg1_); + public final static native long ObjConshdlr_scip_proptiming__get(long jarg1, ObjConshdlr jarg1_); + public final static native long ObjConshdlr_scip_presoltiming__get(long jarg1, ObjConshdlr jarg1_); + public final static native long new_ObjConshdlr(long jarg1, String jarg2, String jarg3, int jarg4, int jarg5, int jarg6, int jarg7, int jarg8, int jarg9, int jarg10, long jarg11, long jarg12, long jarg13, long jarg14, long jarg15); + public final static native void delete_ObjConshdlr(long jarg1); + public final static native int ObjConshdlr_scip_free(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3); + public final static native int ObjConshdlr_scip_freeSwigExplicitObjConshdlr(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3); + public final static native int ObjConshdlr_scip_init(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, int jarg5); + public final static native int ObjConshdlr_scip_initSwigExplicitObjConshdlr(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, int jarg5); + public final static native int ObjConshdlr_scip_exit(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, int jarg5); + public final static native int ObjConshdlr_scip_exitSwigExplicitObjConshdlr(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, int jarg5); + public final static native int ObjConshdlr_scip_initpre(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, int jarg5); + public final static native int ObjConshdlr_scip_initpreSwigExplicitObjConshdlr(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, int jarg5); + public final static native int ObjConshdlr_scip_exitpre(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, int jarg5); + public final static native int ObjConshdlr_scip_exitpreSwigExplicitObjConshdlr(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, int jarg5); + public final static native int ObjConshdlr_scip_initsol(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, int jarg5); + public final static native int ObjConshdlr_scip_initsolSwigExplicitObjConshdlr(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, int jarg5); + public final static native int ObjConshdlr_scip_exitsol(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, int jarg5, long jarg6); + public final static native int ObjConshdlr_scip_exitsolSwigExplicitObjConshdlr(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, int jarg5, long jarg6); + public final static native int ObjConshdlr_scip_delete(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, long jarg5); + public final static native int ObjConshdlr_scip_deleteSwigExplicitObjConshdlr(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, long jarg5); + public final static native int ObjConshdlr_scip_trans(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, long jarg5); + public final static native int ObjConshdlr_scip_transSwigExplicitObjConshdlr(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, long jarg5); + public final static native int ObjConshdlr_scip_initlp(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, int jarg5, long jarg6); + public final static native int ObjConshdlr_scip_initlpSwigExplicitObjConshdlr(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, int jarg5, long jarg6); + public final static native int ObjConshdlr_scip_sepalp(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, int jarg5, int jarg6, long jarg7); + public final static native int ObjConshdlr_scip_sepalpSwigExplicitObjConshdlr(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, int jarg5, int jarg6, long jarg7); + public final static native int ObjConshdlr_scip_sepasol(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, int jarg5, int jarg6, long jarg7, long jarg8); + public final static native int ObjConshdlr_scip_sepasolSwigExplicitObjConshdlr(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, int jarg5, int jarg6, long jarg7, long jarg8); + public final static native int ObjConshdlr_scip_enfolp(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, int jarg5, int jarg6, long jarg7, long jarg8); + public final static native int ObjConshdlr_scip_enfolpSwigExplicitObjConshdlr(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, int jarg5, int jarg6, long jarg7, long jarg8); + public final static native int ObjConshdlr_scip_enforelax(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, long jarg5, int jarg6, int jarg7, long jarg8, long jarg9); + public final static native int ObjConshdlr_scip_enforelaxSwigExplicitObjConshdlr(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, long jarg5, int jarg6, int jarg7, long jarg8, long jarg9); + public final static native int ObjConshdlr_scip_enfops(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, int jarg5, int jarg6, long jarg7, long jarg8, long jarg9); + public final static native int ObjConshdlr_scip_enfopsSwigExplicitObjConshdlr(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, int jarg5, int jarg6, long jarg7, long jarg8, long jarg9); + public final static native int ObjConshdlr_scip_check(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, int jarg5, long jarg6, long jarg7, long jarg8, long jarg9, long jarg10, long jarg11); + public final static native int ObjConshdlr_scip_checkSwigExplicitObjConshdlr(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, int jarg5, long jarg6, long jarg7, long jarg8, long jarg9, long jarg10, long jarg11); + public final static native int ObjConshdlr_scip_prop(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, int jarg5, int jarg6, int jarg7, long jarg8, long jarg9); + public final static native int ObjConshdlr_scip_propSwigExplicitObjConshdlr(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, int jarg5, int jarg6, int jarg7, long jarg8, long jarg9); + public final static native int ObjConshdlr_scip_presol(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, int jarg5, int jarg6, long jarg7, int jarg8, int jarg9, int jarg10, int jarg11, int jarg12, int jarg13, int jarg14, int jarg15, int jarg16, int jarg17, long jarg18, long jarg19, long jarg20, long jarg21, long jarg22, long jarg23, long jarg24, long jarg25, long jarg26, long jarg27, long jarg28); + public final static native int ObjConshdlr_scip_presolSwigExplicitObjConshdlr(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, int jarg5, int jarg6, long jarg7, int jarg8, int jarg9, int jarg10, int jarg11, int jarg12, int jarg13, int jarg14, int jarg15, int jarg16, int jarg17, long jarg18, long jarg19, long jarg20, long jarg21, long jarg22, long jarg23, long jarg24, long jarg25, long jarg26, long jarg27, long jarg28); + public final static native int ObjConshdlr_scip_resprop(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, long jarg5, int jarg6, int jarg7, long jarg8, double jarg9, long jarg10); + public final static native int ObjConshdlr_scip_respropSwigExplicitObjConshdlr(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, long jarg5, int jarg6, int jarg7, long jarg8, double jarg9, long jarg10); + public final static native int ObjConshdlr_scip_lock(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, int jarg5, int jarg6, int jarg7); + public final static native int ObjConshdlr_scip_lockSwigExplicitObjConshdlr(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, int jarg5, int jarg6, int jarg7); + public final static native int ObjConshdlr_scip_active(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4); + public final static native int ObjConshdlr_scip_activeSwigExplicitObjConshdlr(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4); + public final static native int ObjConshdlr_scip_deactive(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4); + public final static native int ObjConshdlr_scip_deactiveSwigExplicitObjConshdlr(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4); + public final static native int ObjConshdlr_scip_enable(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4); + public final static native int ObjConshdlr_scip_enableSwigExplicitObjConshdlr(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4); + public final static native int ObjConshdlr_scip_disable(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4); + public final static native int ObjConshdlr_scip_disableSwigExplicitObjConshdlr(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4); + public final static native int ObjConshdlr_scip_delvars(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, int jarg5); + public final static native int ObjConshdlr_scip_delvarsSwigExplicitObjConshdlr(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, int jarg5); + public final static native int ObjConshdlr_scip_print(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, long jarg5); + public final static native int ObjConshdlr_scip_printSwigExplicitObjConshdlr(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, long jarg5); + public final static native int ObjConshdlr_scip_copy(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, String jarg4, long jarg5, long jarg6, long jarg7, long jarg8, long jarg9, long jarg10, long jarg11, long jarg12, long jarg13, long jarg14, long jarg15, long jarg16, long jarg17, long jarg18, long jarg19, long jarg20, long jarg21); + public final static native int ObjConshdlr_scip_copySwigExplicitObjConshdlr(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, String jarg4, long jarg5, long jarg6, long jarg7, long jarg8, long jarg9, long jarg10, long jarg11, long jarg12, long jarg13, long jarg14, long jarg15, long jarg16, long jarg17, long jarg18, long jarg19, long jarg20, long jarg21); + public final static native int ObjConshdlr_scip_parse(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, String jarg5, String jarg6, long jarg7, long jarg8, long jarg9, long jarg10, long jarg11, long jarg12, long jarg13, long jarg14, long jarg15, long jarg16, long jarg17); + public final static native int ObjConshdlr_scip_parseSwigExplicitObjConshdlr(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, String jarg5, String jarg6, long jarg7, long jarg8, long jarg9, long jarg10, long jarg11, long jarg12, long jarg13, long jarg14, long jarg15, long jarg16, long jarg17); + public final static native int ObjConshdlr_scip_getvars(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, long jarg5, int jarg6, long jarg7); + public final static native int ObjConshdlr_scip_getvarsSwigExplicitObjConshdlr(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, long jarg5, int jarg6, long jarg7); + public final static native int ObjConshdlr_scip_getnvars(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, long jarg5, long jarg6); + public final static native int ObjConshdlr_scip_getnvarsSwigExplicitObjConshdlr(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, long jarg5, long jarg6); + public final static native int ObjConshdlr_scip_getdivebdchgs(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, long jarg5, long jarg6, long jarg7); + public final static native int ObjConshdlr_scip_getdivebdchgsSwigExplicitObjConshdlr(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, long jarg5, long jarg6, long jarg7); + public final static native int ObjConshdlr_scip_getpermsymgraph(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, long jarg5, long jarg6); + public final static native int ObjConshdlr_scip_getpermsymgraphSwigExplicitObjConshdlr(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, long jarg5, long jarg6); + public final static native int ObjConshdlr_scip_getsignedpermsymgraph(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, long jarg5, long jarg6); + public final static native int ObjConshdlr_scip_getsignedpermsymgraphSwigExplicitObjConshdlr(long jarg1, ObjConshdlr jarg1_, long jarg2, long jarg3, long jarg4, long jarg5, long jarg6); + public final static native void ObjConshdlr_director_connect(ObjConshdlr obj, long cptr, boolean mem_own, boolean weak_global); + public final static native void ObjConshdlr_change_ownership(ObjConshdlr obj, long cptr, boolean take_or_release); + public final static native int SCIPincludeObjConshdlr(long jarg1, long jarg2, ObjConshdlr jarg2_, long jarg3); + public final static native long SCIPfindObjConshdlr(long jarg1, String jarg2); + public final static native long SCIPgetObjConshdlr(long jarg1, long jarg2); + public final static native int SCIPaddVarLocksType(long jarg1, long jarg2, int jarg3, int jarg4, int jarg5); + public final static native int SCIPaddConsLocksType(long jarg1, long jarg2, int jarg3, int jarg4, int jarg5); + public final static native void setResult(long jarg1, int jarg2); public static void SwigDirector_ObjMessagehdlr_scip_error(ObjMessagehdlr jself, long messagehdlr, long file, String msg) { jself.scip_error((messagehdlr == 0) ? null : new SWIGTYPE_p_SCIP_Messagehdlr(messagehdlr, false), (file == 0) ? null : new SWIGTYPE_p_FILE(file, false), msg); @@ -298,6 +557,126 @@ public static void SwigDirector_ObjMessagehdlr_scip_info(ObjMessagehdlr jself, l public static int SwigDirector_ObjMessagehdlr_scip_free(ObjMessagehdlr jself, long messagehdlr) { return (jself.scip_free((messagehdlr == 0) ? null : new SWIGTYPE_p_SCIP_Messagehdlr(messagehdlr, false))).swigValue(); } + public static int SwigDirector_ObjEventhdlr_scip_free(ObjEventhdlr jself, long scip, long eventhdlr) { + return (jself.scip_free((scip == 0) ? null : new SWIGTYPE_p_SCIP(scip, false), (eventhdlr == 0) ? null : new SWIGTYPE_p_SCIP_EVENTHDLR(eventhdlr, false))).swigValue(); + } + public static int SwigDirector_ObjEventhdlr_scip_init(ObjEventhdlr jself, long scip, long eventhdlr) { + return (jself.scip_init((scip == 0) ? null : new SWIGTYPE_p_SCIP(scip, false), (eventhdlr == 0) ? null : new SWIGTYPE_p_SCIP_EVENTHDLR(eventhdlr, false))).swigValue(); + } + public static int SwigDirector_ObjEventhdlr_scip_exit(ObjEventhdlr jself, long scip, long eventhdlr) { + return (jself.scip_exit((scip == 0) ? null : new SWIGTYPE_p_SCIP(scip, false), (eventhdlr == 0) ? null : new SWIGTYPE_p_SCIP_EVENTHDLR(eventhdlr, false))).swigValue(); + } + public static int SwigDirector_ObjEventhdlr_scip_initsol(ObjEventhdlr jself, long scip, long eventhdlr) { + return (jself.scip_initsol((scip == 0) ? null : new SWIGTYPE_p_SCIP(scip, false), (eventhdlr == 0) ? null : new SWIGTYPE_p_SCIP_EVENTHDLR(eventhdlr, false))).swigValue(); + } + public static int SwigDirector_ObjEventhdlr_scip_exitsol(ObjEventhdlr jself, long scip, long eventhdlr) { + return (jself.scip_exitsol((scip == 0) ? null : new SWIGTYPE_p_SCIP(scip, false), (eventhdlr == 0) ? null : new SWIGTYPE_p_SCIP_EVENTHDLR(eventhdlr, false))).swigValue(); + } + public static int SwigDirector_ObjEventhdlr_scip_delete(ObjEventhdlr jself, long scip, long eventhdlr, long eventdata) { + return (jself.scip_delete((scip == 0) ? null : new SWIGTYPE_p_SCIP(scip, false), (eventhdlr == 0) ? null : new SWIGTYPE_p_SCIP_EVENTHDLR(eventhdlr, false), (eventdata == 0) ? null : new SWIGTYPE_p_p_SCIP_EVENTDATA(eventdata, false))).swigValue(); + } + public static int SwigDirector_ObjEventhdlr_scip_exec(ObjEventhdlr jself, long scip, long eventhdlr, long event, long eventdata) { + return (jself.scip_exec((scip == 0) ? null : new SWIGTYPE_p_SCIP(scip, false), (eventhdlr == 0) ? null : new SWIGTYPE_p_SCIP_EVENTHDLR(eventhdlr, false), (event == 0) ? null : new SCIP_Event(event, false), (eventdata == 0) ? null : new SWIGTYPE_p_SCIP_EVENTDATA(eventdata, false))).swigValue(); + } + public static int SwigDirector_ObjConshdlr_scip_free(ObjConshdlr jself, long scip, long conshdlr) { + return (jself.scip_free((scip == 0) ? null : new SWIGTYPE_p_SCIP(scip, false), (conshdlr == 0) ? null : new SWIGTYPE_p_SCIP_CONSHDLR(conshdlr, false))).swigValue(); + } + public static int SwigDirector_ObjConshdlr_scip_init(ObjConshdlr jself, long scip, long conshdlr, long conss, int nconss) { + return (jself.scip_init((scip == 0) ? null : new SWIGTYPE_p_SCIP(scip, false), (conshdlr == 0) ? null : new SWIGTYPE_p_SCIP_CONSHDLR(conshdlr, false), (conss == 0) ? null : new SWIGTYPE_p_p_SCIP_CONS(conss, false), nconss)).swigValue(); + } + public static int SwigDirector_ObjConshdlr_scip_exit(ObjConshdlr jself, long scip, long conshdlr, long conss, int nconss) { + return (jself.scip_exit((scip == 0) ? null : new SWIGTYPE_p_SCIP(scip, false), (conshdlr == 0) ? null : new SWIGTYPE_p_SCIP_CONSHDLR(conshdlr, false), (conss == 0) ? null : new SWIGTYPE_p_p_SCIP_CONS(conss, false), nconss)).swigValue(); + } + public static int SwigDirector_ObjConshdlr_scip_initpre(ObjConshdlr jself, long scip, long conshdlr, long conss, int nconss) { + return (jself.scip_initpre((scip == 0) ? null : new SWIGTYPE_p_SCIP(scip, false), (conshdlr == 0) ? null : new SWIGTYPE_p_SCIP_CONSHDLR(conshdlr, false), (conss == 0) ? null : new SWIGTYPE_p_p_SCIP_CONS(conss, false), nconss)).swigValue(); + } + public static int SwigDirector_ObjConshdlr_scip_exitpre(ObjConshdlr jself, long scip, long conshdlr, long conss, int nconss) { + return (jself.scip_exitpre((scip == 0) ? null : new SWIGTYPE_p_SCIP(scip, false), (conshdlr == 0) ? null : new SWIGTYPE_p_SCIP_CONSHDLR(conshdlr, false), (conss == 0) ? null : new SWIGTYPE_p_p_SCIP_CONS(conss, false), nconss)).swigValue(); + } + public static int SwigDirector_ObjConshdlr_scip_initsol(ObjConshdlr jself, long scip, long conshdlr, long conss, int nconss) { + return (jself.scip_initsol((scip == 0) ? null : new SWIGTYPE_p_SCIP(scip, false), (conshdlr == 0) ? null : new SWIGTYPE_p_SCIP_CONSHDLR(conshdlr, false), (conss == 0) ? null : new SWIGTYPE_p_p_SCIP_CONS(conss, false), nconss)).swigValue(); + } + public static int SwigDirector_ObjConshdlr_scip_exitsol(ObjConshdlr jself, long scip, long conshdlr, long conss, int nconss, long restart) { + return (jself.scip_exitsol((scip == 0) ? null : new SWIGTYPE_p_SCIP(scip, false), (conshdlr == 0) ? null : new SWIGTYPE_p_SCIP_CONSHDLR(conshdlr, false), (conss == 0) ? null : new SWIGTYPE_p_p_SCIP_CONS(conss, false), nconss, restart)).swigValue(); + } + public static int SwigDirector_ObjConshdlr_scip_delete(ObjConshdlr jself, long scip, long conshdlr, long cons, long consdata) { + return (jself.scip_delete((scip == 0) ? null : new SWIGTYPE_p_SCIP(scip, false), (conshdlr == 0) ? null : new SWIGTYPE_p_SCIP_CONSHDLR(conshdlr, false), (cons == 0) ? null : new SWIGTYPE_p_SCIP_CONS(cons, false), (consdata == 0) ? null : new SWIGTYPE_p_p_SCIP_CONSDATA(consdata, false))).swigValue(); + } + public static int SwigDirector_ObjConshdlr_scip_trans(ObjConshdlr jself, long scip, long conshdlr, long sourcecons, long targetcons) { + return (jself.scip_trans((scip == 0) ? null : new SWIGTYPE_p_SCIP(scip, false), (conshdlr == 0) ? null : new SWIGTYPE_p_SCIP_CONSHDLR(conshdlr, false), (sourcecons == 0) ? null : new SWIGTYPE_p_SCIP_CONS(sourcecons, false), (targetcons == 0) ? null : new SWIGTYPE_p_p_SCIP_CONS(targetcons, false))).swigValue(); + } + public static int SwigDirector_ObjConshdlr_scip_initlp(ObjConshdlr jself, long scip, long conshdlr, long conss, int nconss, long infeasible) { + return (jself.scip_initlp((scip == 0) ? null : new SWIGTYPE_p_SCIP(scip, false), (conshdlr == 0) ? null : new SWIGTYPE_p_SCIP_CONSHDLR(conshdlr, false), (conss == 0) ? null : new SWIGTYPE_p_p_SCIP_CONS(conss, false), nconss, (infeasible == 0) ? null : new SWIGTYPE_p_unsigned_int(infeasible, false))).swigValue(); + } + public static int SwigDirector_ObjConshdlr_scip_sepalp(ObjConshdlr jself, long scip, long conshdlr, long conss, int nconss, int nusefulconss, long result) { + return (jself.scip_sepalp((scip == 0) ? null : new SWIGTYPE_p_SCIP(scip, false), (conshdlr == 0) ? null : new SWIGTYPE_p_SCIP_CONSHDLR(conshdlr, false), (conss == 0) ? null : new SWIGTYPE_p_p_SCIP_CONS(conss, false), nconss, nusefulconss, (result == 0) ? null : new SWIGTYPE_p_SCIP_Result(result, false))).swigValue(); + } + public static int SwigDirector_ObjConshdlr_scip_sepasol(ObjConshdlr jself, long scip, long conshdlr, long conss, int nconss, int nusefulconss, long sol, long result) { + return (jself.scip_sepasol((scip == 0) ? null : new SWIGTYPE_p_SCIP(scip, false), (conshdlr == 0) ? null : new SWIGTYPE_p_SCIP_CONSHDLR(conshdlr, false), (conss == 0) ? null : new SWIGTYPE_p_p_SCIP_CONS(conss, false), nconss, nusefulconss, (sol == 0) ? null : new SWIGTYPE_p_SCIP_SOL(sol, false), (result == 0) ? null : new SWIGTYPE_p_SCIP_Result(result, false))).swigValue(); + } + public static int SwigDirector_ObjConshdlr_scip_enfolp(ObjConshdlr jself, long scip, long conshdlr, long conss, int nconss, int nusefulconss, long solinfeasible, long result) { + return (jself.scip_enfolp((scip == 0) ? null : new SWIGTYPE_p_SCIP(scip, false), (conshdlr == 0) ? null : new SWIGTYPE_p_SCIP_CONSHDLR(conshdlr, false), (conss == 0) ? null : new SWIGTYPE_p_p_SCIP_CONS(conss, false), nconss, nusefulconss, solinfeasible, (result == 0) ? null : new SWIGTYPE_p_SCIP_Result(result, false))).swigValue(); + } + public static int SwigDirector_ObjConshdlr_scip_enforelax(ObjConshdlr jself, long scip, long sol, long conshdlr, long conss, int nconss, int nusefulconss, long solinfeasible, long result) { + return (jself.scip_enforelax((scip == 0) ? null : new SWIGTYPE_p_SCIP(scip, false), (sol == 0) ? null : new SWIGTYPE_p_SCIP_SOL(sol, false), (conshdlr == 0) ? null : new SWIGTYPE_p_SCIP_CONSHDLR(conshdlr, false), (conss == 0) ? null : new SWIGTYPE_p_p_SCIP_CONS(conss, false), nconss, nusefulconss, solinfeasible, (result == 0) ? null : new SWIGTYPE_p_SCIP_Result(result, false))).swigValue(); + } + public static int SwigDirector_ObjConshdlr_scip_enfops(ObjConshdlr jself, long scip, long conshdlr, long conss, int nconss, int nusefulconss, long solinfeasible, long objinfeasible, long result) { + return (jself.scip_enfops((scip == 0) ? null : new SWIGTYPE_p_SCIP(scip, false), (conshdlr == 0) ? null : new SWIGTYPE_p_SCIP_CONSHDLR(conshdlr, false), (conss == 0) ? null : new SWIGTYPE_p_p_SCIP_CONS(conss, false), nconss, nusefulconss, solinfeasible, objinfeasible, (result == 0) ? null : new SWIGTYPE_p_SCIP_Result(result, false))).swigValue(); + } + public static int SwigDirector_ObjConshdlr_scip_check(ObjConshdlr jself, long scip, long conshdlr, long conss, int nconss, long sol, long checkintegrality, long checklprows, long printreason, long completely, long result) { + return (jself.scip_check((scip == 0) ? null : new SWIGTYPE_p_SCIP(scip, false), (conshdlr == 0) ? null : new SWIGTYPE_p_SCIP_CONSHDLR(conshdlr, false), (conss == 0) ? null : new SWIGTYPE_p_p_SCIP_CONS(conss, false), nconss, (sol == 0) ? null : new SWIGTYPE_p_SCIP_SOL(sol, false), checkintegrality, checklprows, printreason, completely, (result == 0) ? null : new SWIGTYPE_p_SCIP_Result(result, false))).swigValue(); + } + public static int SwigDirector_ObjConshdlr_scip_prop(ObjConshdlr jself, long scip, long conshdlr, long conss, int nconss, int nusefulconss, int nmarkedconss, long proptiming, long result) { + return (jself.scip_prop((scip == 0) ? null : new SWIGTYPE_p_SCIP(scip, false), (conshdlr == 0) ? null : new SWIGTYPE_p_SCIP_CONSHDLR(conshdlr, false), (conss == 0) ? null : new SWIGTYPE_p_p_SCIP_CONS(conss, false), nconss, nusefulconss, nmarkedconss, new SWIGTYPE_p_SCIP_PROPTIMING(proptiming, true), (result == 0) ? null : new SWIGTYPE_p_SCIP_Result(result, false))).swigValue(); + } + public static int SwigDirector_ObjConshdlr_scip_presol(ObjConshdlr jself, long scip, long conshdlr, long conss, int nconss, int nrounds, long presoltiming, int nnewfixedvars, int nnewaggrvars, int nnewchgvartypes, int nnewchgbds, int nnewholes, int nnewdelconss, int nnewaddconss, int nnewupgdconss, int nnewchgcoefs, int nnewchgsides, long nfixedvars, long naggrvars, long nchgvartypes, long nchgbds, long naddholes, long ndelconss, long naddconss, long nupgdconss, long nchgcoefs, long nchgsides, long result) { + return (jself.scip_presol((scip == 0) ? null : new SWIGTYPE_p_SCIP(scip, false), (conshdlr == 0) ? null : new SWIGTYPE_p_SCIP_CONSHDLR(conshdlr, false), (conss == 0) ? null : new SWIGTYPE_p_p_SCIP_CONS(conss, false), nconss, nrounds, new SWIGTYPE_p_SCIP_PRESOLTIMING(presoltiming, true), nnewfixedvars, nnewaggrvars, nnewchgvartypes, nnewchgbds, nnewholes, nnewdelconss, nnewaddconss, nnewupgdconss, nnewchgcoefs, nnewchgsides, (nfixedvars == 0) ? null : new SWIGTYPE_p_int(nfixedvars, false), (naggrvars == 0) ? null : new SWIGTYPE_p_int(naggrvars, false), (nchgvartypes == 0) ? null : new SWIGTYPE_p_int(nchgvartypes, false), (nchgbds == 0) ? null : new SWIGTYPE_p_int(nchgbds, false), (naddholes == 0) ? null : new SWIGTYPE_p_int(naddholes, false), (ndelconss == 0) ? null : new SWIGTYPE_p_int(ndelconss, false), (naddconss == 0) ? null : new SWIGTYPE_p_int(naddconss, false), (nupgdconss == 0) ? null : new SWIGTYPE_p_int(nupgdconss, false), (nchgcoefs == 0) ? null : new SWIGTYPE_p_int(nchgcoefs, false), (nchgsides == 0) ? null : new SWIGTYPE_p_int(nchgsides, false), (result == 0) ? null : new SWIGTYPE_p_SCIP_Result(result, false))).swigValue(); + } + public static int SwigDirector_ObjConshdlr_scip_resprop(ObjConshdlr jself, long scip, long conshdlr, long cons, long infervar, int inferinfo, int boundtype, long bdchgidx, double relaxedbd, long result) { + return (jself.scip_resprop((scip == 0) ? null : new SWIGTYPE_p_SCIP(scip, false), (conshdlr == 0) ? null : new SWIGTYPE_p_SCIP_CONSHDLR(conshdlr, false), (cons == 0) ? null : new SWIGTYPE_p_SCIP_CONS(cons, false), (infervar == 0) ? null : new SWIGTYPE_p_SCIP_VAR(infervar, false), inferinfo, SCIP_BoundType.swigToEnum(boundtype), (bdchgidx == 0) ? null : new SWIGTYPE_p_SCIP_BDCHGIDX(bdchgidx, false), relaxedbd, (result == 0) ? null : new SWIGTYPE_p_SCIP_Result(result, false))).swigValue(); + } + public static int SwigDirector_ObjConshdlr_scip_lock(ObjConshdlr jself, long scip, long conshdlr, long cons, int locktype, int nlockspos, int nlocksneg) { + return (jself.scip_lock((scip == 0) ? null : new SWIGTYPE_p_SCIP(scip, false), (conshdlr == 0) ? null : new SWIGTYPE_p_SCIP_CONSHDLR(conshdlr, false), (cons == 0) ? null : new SWIGTYPE_p_SCIP_CONS(cons, false), SCIP_LockType.swigToEnum(locktype), nlockspos, nlocksneg)).swigValue(); + } + public static int SwigDirector_ObjConshdlr_scip_active(ObjConshdlr jself, long scip, long conshdlr, long cons) { + return (jself.scip_active((scip == 0) ? null : new SWIGTYPE_p_SCIP(scip, false), (conshdlr == 0) ? null : new SWIGTYPE_p_SCIP_CONSHDLR(conshdlr, false), (cons == 0) ? null : new SWIGTYPE_p_SCIP_CONS(cons, false))).swigValue(); + } + public static int SwigDirector_ObjConshdlr_scip_deactive(ObjConshdlr jself, long scip, long conshdlr, long cons) { + return (jself.scip_deactive((scip == 0) ? null : new SWIGTYPE_p_SCIP(scip, false), (conshdlr == 0) ? null : new SWIGTYPE_p_SCIP_CONSHDLR(conshdlr, false), (cons == 0) ? null : new SWIGTYPE_p_SCIP_CONS(cons, false))).swigValue(); + } + public static int SwigDirector_ObjConshdlr_scip_enable(ObjConshdlr jself, long scip, long conshdlr, long cons) { + return (jself.scip_enable((scip == 0) ? null : new SWIGTYPE_p_SCIP(scip, false), (conshdlr == 0) ? null : new SWIGTYPE_p_SCIP_CONSHDLR(conshdlr, false), (cons == 0) ? null : new SWIGTYPE_p_SCIP_CONS(cons, false))).swigValue(); + } + public static int SwigDirector_ObjConshdlr_scip_disable(ObjConshdlr jself, long scip, long conshdlr, long cons) { + return (jself.scip_disable((scip == 0) ? null : new SWIGTYPE_p_SCIP(scip, false), (conshdlr == 0) ? null : new SWIGTYPE_p_SCIP_CONSHDLR(conshdlr, false), (cons == 0) ? null : new SWIGTYPE_p_SCIP_CONS(cons, false))).swigValue(); + } + public static int SwigDirector_ObjConshdlr_scip_delvars(ObjConshdlr jself, long scip, long conshdlr, long conss, int nconss) { + return (jself.scip_delvars((scip == 0) ? null : new SWIGTYPE_p_SCIP(scip, false), (conshdlr == 0) ? null : new SWIGTYPE_p_SCIP_CONSHDLR(conshdlr, false), (conss == 0) ? null : new SWIGTYPE_p_p_SCIP_CONS(conss, false), nconss)).swigValue(); + } + public static int SwigDirector_ObjConshdlr_scip_print(ObjConshdlr jself, long scip, long conshdlr, long cons, long file) { + return (jself.scip_print((scip == 0) ? null : new SWIGTYPE_p_SCIP(scip, false), (conshdlr == 0) ? null : new SWIGTYPE_p_SCIP_CONSHDLR(conshdlr, false), (cons == 0) ? null : new SWIGTYPE_p_SCIP_CONS(cons, false), (file == 0) ? null : new SWIGTYPE_p_FILE(file, false))).swigValue(); + } + public static int SwigDirector_ObjConshdlr_scip_copy(ObjConshdlr jself, long scip, long cons, String name, long sourcescip, long sourceconshdlr, long sourcecons, long varmap, long consmap, long initial, long separate, long enforce, long check, long propagate, long local, long modifiable, long dynamic, long removable, long stickingatnode, long global, long valid) { + return (jself.scip_copy((scip == 0) ? null : new SWIGTYPE_p_SCIP(scip, false), (cons == 0) ? null : new SWIGTYPE_p_p_SCIP_CONS(cons, false), name, (sourcescip == 0) ? null : new SWIGTYPE_p_SCIP(sourcescip, false), (sourceconshdlr == 0) ? null : new SWIGTYPE_p_SCIP_CONSHDLR(sourceconshdlr, false), (sourcecons == 0) ? null : new SWIGTYPE_p_SCIP_CONS(sourcecons, false), (varmap == 0) ? null : new SWIGTYPE_p_SCIP_HASHMAP(varmap, false), (consmap == 0) ? null : new SWIGTYPE_p_SCIP_HASHMAP(consmap, false), initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, stickingatnode, global, (valid == 0) ? null : new SWIGTYPE_p_unsigned_int(valid, false))).swigValue(); + } + public static int SwigDirector_ObjConshdlr_scip_parse(ObjConshdlr jself, long scip, long conshdlr, long cons, String name, String str, long initial, long separate, long enforce, long check, long propagate, long local, long modifiable, long dynamic, long removable, long stickingatnode, long success) { + return (jself.scip_parse((scip == 0) ? null : new SWIGTYPE_p_SCIP(scip, false), (conshdlr == 0) ? null : new SWIGTYPE_p_SCIP_CONSHDLR(conshdlr, false), (cons == 0) ? null : new SWIGTYPE_p_p_SCIP_CONS(cons, false), name, str, initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, stickingatnode, (success == 0) ? null : new SWIGTYPE_p_unsigned_int(success, false))).swigValue(); + } + public static int SwigDirector_ObjConshdlr_scip_getvars(ObjConshdlr jself, long scip, long conshdlr, long cons, long vars, int varssize, long success) { + return (jself.scip_getvars((scip == 0) ? null : new SWIGTYPE_p_SCIP(scip, false), (conshdlr == 0) ? null : new SWIGTYPE_p_SCIP_CONSHDLR(conshdlr, false), (cons == 0) ? null : new SWIGTYPE_p_SCIP_CONS(cons, false), (vars == 0) ? null : new SWIGTYPE_p_p_SCIP_VAR(vars, false), varssize, (success == 0) ? null : new SWIGTYPE_p_unsigned_int(success, false))).swigValue(); + } + public static int SwigDirector_ObjConshdlr_scip_getnvars(ObjConshdlr jself, long scip, long conshdlr, long cons, long nvars, long success) { + return (jself.scip_getnvars((scip == 0) ? null : new SWIGTYPE_p_SCIP(scip, false), (conshdlr == 0) ? null : new SWIGTYPE_p_SCIP_CONSHDLR(conshdlr, false), (cons == 0) ? null : new SWIGTYPE_p_SCIP_CONS(cons, false), (nvars == 0) ? null : new SWIGTYPE_p_int(nvars, false), (success == 0) ? null : new SWIGTYPE_p_unsigned_int(success, false))).swigValue(); + } + public static int SwigDirector_ObjConshdlr_scip_getdivebdchgs(ObjConshdlr jself, long scip, long conshdlr, long diveset, long sol, long success, long infeasible) { + return (jself.scip_getdivebdchgs((scip == 0) ? null : new SWIGTYPE_p_SCIP(scip, false), (conshdlr == 0) ? null : new SWIGTYPE_p_SCIP_CONSHDLR(conshdlr, false), (diveset == 0) ? null : new SWIGTYPE_p_SCIP_DIVESET(diveset, false), (sol == 0) ? null : new SWIGTYPE_p_SCIP_SOL(sol, false), (success == 0) ? null : new SWIGTYPE_p_unsigned_int(success, false), (infeasible == 0) ? null : new SWIGTYPE_p_unsigned_int(infeasible, false))).swigValue(); + } + public static int SwigDirector_ObjConshdlr_scip_getpermsymgraph(ObjConshdlr jself, long scip, long conshdlr, long cons, long graph, long success) { + return (jself.scip_getpermsymgraph((scip == 0) ? null : new SWIGTYPE_p_SCIP(scip, false), (conshdlr == 0) ? null : new SWIGTYPE_p_SCIP_CONSHDLR(conshdlr, false), (cons == 0) ? null : new SWIGTYPE_p_SCIP_CONS(cons, false), (graph == 0) ? null : new SWIGTYPE_p_SYM_GRAPH(graph, false), (success == 0) ? null : new SWIGTYPE_p_unsigned_int(success, false))).swigValue(); + } + public static int SwigDirector_ObjConshdlr_scip_getsignedpermsymgraph(ObjConshdlr jself, long scip, long conshdlr, long cons, long graph, long success) { + return (jself.scip_getsignedpermsymgraph((scip == 0) ? null : new SWIGTYPE_p_SCIP(scip, false), (conshdlr == 0) ? null : new SWIGTYPE_p_SCIP_CONSHDLR(conshdlr, false), (cons == 0) ? null : new SWIGTYPE_p_SCIP_CONS(cons, false), (graph == 0) ? null : new SWIGTYPE_p_SYM_GRAPH(graph, false), (success == 0) ? null : new SWIGTYPE_p_unsigned_int(success, false))).swigValue(); + } private final static native void swig_module_init(); static { diff --git a/java/jscip/SCIP_Event.java b/java/jscip/SCIP_Event.java new file mode 100644 index 0000000..df9e232 --- /dev/null +++ b/java/jscip/SCIP_Event.java @@ -0,0 +1,51 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package jscip; + +public class SCIP_Event { + private transient long swigCPtr; + protected transient boolean swigCMemOwn; + + protected SCIP_Event(long cPtr, boolean cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = cPtr; + } + + protected static long getCPtr(SCIP_Event obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + @SuppressWarnings("deprecation") + protected void finalize() { + delete(); + } + + public synchronized void delete() { + if (swigCPtr != 0) { + if (swigCMemOwn) { + swigCMemOwn = false; + SCIPJNIJNI.delete_SCIP_Event(swigCPtr); + } + swigCPtr = 0; + } + } + + public void setEventtype(long value) { + SCIPJNIJNI.SCIP_Event_eventtype_set(swigCPtr, this, value); + } + + public long getEventtype() { + return SCIPJNIJNI.SCIP_Event_eventtype_get(swigCPtr, this); + } + + public SCIP_Event() { + this(SCIPJNIJNI.new_SCIP_Event(), true); + } + +} diff --git a/java/jscip/SCIP_EventBdChg.java b/java/jscip/SCIP_EventBdChg.java new file mode 100644 index 0000000..2617266 --- /dev/null +++ b/java/jscip/SCIP_EventBdChg.java @@ -0,0 +1,68 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package jscip; + +public class SCIP_EventBdChg { + private transient long swigCPtr; + protected transient boolean swigCMemOwn; + + protected SCIP_EventBdChg(long cPtr, boolean cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = cPtr; + } + + protected static long getCPtr(SCIP_EventBdChg obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + @SuppressWarnings("deprecation") + protected void finalize() { + delete(); + } + + public synchronized void delete() { + if (swigCPtr != 0) { + if (swigCMemOwn) { + swigCMemOwn = false; + SCIPJNIJNI.delete_SCIP_EventBdChg(swigCPtr); + } + swigCPtr = 0; + } + } + + public void setOldbound(double value) { + SCIPJNIJNI.SCIP_EventBdChg_oldbound_set(swigCPtr, this, value); + } + + public double getOldbound() { + return SCIPJNIJNI.SCIP_EventBdChg_oldbound_get(swigCPtr, this); + } + + public void setNewbound(double value) { + SCIPJNIJNI.SCIP_EventBdChg_newbound_set(swigCPtr, this, value); + } + + public double getNewbound() { + return SCIPJNIJNI.SCIP_EventBdChg_newbound_get(swigCPtr, this); + } + + public void setVar(SWIGTYPE_p_SCIP_VAR value) { + SCIPJNIJNI.SCIP_EventBdChg_var_set(swigCPtr, this, SWIGTYPE_p_SCIP_VAR.getCPtr(value)); + } + + public SWIGTYPE_p_SCIP_VAR getVar() { + long cPtr = SCIPJNIJNI.SCIP_EventBdChg_var_get(swigCPtr, this); + return (cPtr == 0) ? null : new SWIGTYPE_p_SCIP_VAR(cPtr, false); + } + + public SCIP_EventBdChg() { + this(SCIPJNIJNI.new_SCIP_EventBdChg(), true); + } + +} diff --git a/java/jscip/SCIP_EventHole.java b/java/jscip/SCIP_EventHole.java new file mode 100644 index 0000000..3f5dc8d --- /dev/null +++ b/java/jscip/SCIP_EventHole.java @@ -0,0 +1,68 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package jscip; + +public class SCIP_EventHole { + private transient long swigCPtr; + protected transient boolean swigCMemOwn; + + protected SCIP_EventHole(long cPtr, boolean cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = cPtr; + } + + protected static long getCPtr(SCIP_EventHole obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + @SuppressWarnings("deprecation") + protected void finalize() { + delete(); + } + + public synchronized void delete() { + if (swigCPtr != 0) { + if (swigCMemOwn) { + swigCMemOwn = false; + SCIPJNIJNI.delete_SCIP_EventHole(swigCPtr); + } + swigCPtr = 0; + } + } + + public void setLeft(double value) { + SCIPJNIJNI.SCIP_EventHole_left_set(swigCPtr, this, value); + } + + public double getLeft() { + return SCIPJNIJNI.SCIP_EventHole_left_get(swigCPtr, this); + } + + public void setRight(double value) { + SCIPJNIJNI.SCIP_EventHole_right_set(swigCPtr, this, value); + } + + public double getRight() { + return SCIPJNIJNI.SCIP_EventHole_right_get(swigCPtr, this); + } + + public void setVar(SWIGTYPE_p_SCIP_VAR value) { + SCIPJNIJNI.SCIP_EventHole_var_set(swigCPtr, this, SWIGTYPE_p_SCIP_VAR.getCPtr(value)); + } + + public SWIGTYPE_p_SCIP_VAR getVar() { + long cPtr = SCIPJNIJNI.SCIP_EventHole_var_get(swigCPtr, this); + return (cPtr == 0) ? null : new SWIGTYPE_p_SCIP_VAR(cPtr, false); + } + + public SCIP_EventHole() { + this(SCIPJNIJNI.new_SCIP_EventHole(), true); + } + +} diff --git a/java/jscip/SCIP_EventImplAdd.java b/java/jscip/SCIP_EventImplAdd.java new file mode 100644 index 0000000..76e4471 --- /dev/null +++ b/java/jscip/SCIP_EventImplAdd.java @@ -0,0 +1,52 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package jscip; + +public class SCIP_EventImplAdd { + private transient long swigCPtr; + protected transient boolean swigCMemOwn; + + protected SCIP_EventImplAdd(long cPtr, boolean cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = cPtr; + } + + protected static long getCPtr(SCIP_EventImplAdd obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + @SuppressWarnings("deprecation") + protected void finalize() { + delete(); + } + + public synchronized void delete() { + if (swigCPtr != 0) { + if (swigCMemOwn) { + swigCMemOwn = false; + SCIPJNIJNI.delete_SCIP_EventImplAdd(swigCPtr); + } + swigCPtr = 0; + } + } + + public void setVar(SWIGTYPE_p_SCIP_VAR value) { + SCIPJNIJNI.SCIP_EventImplAdd_var_set(swigCPtr, this, SWIGTYPE_p_SCIP_VAR.getCPtr(value)); + } + + public SWIGTYPE_p_SCIP_VAR getVar() { + long cPtr = SCIPJNIJNI.SCIP_EventImplAdd_var_get(swigCPtr, this); + return (cPtr == 0) ? null : new SWIGTYPE_p_SCIP_VAR(cPtr, false); + } + + public SCIP_EventImplAdd() { + this(SCIPJNIJNI.new_SCIP_EventImplAdd(), true); + } + +} diff --git a/java/jscip/SCIP_EventObjChg.java b/java/jscip/SCIP_EventObjChg.java new file mode 100644 index 0000000..7f238a3 --- /dev/null +++ b/java/jscip/SCIP_EventObjChg.java @@ -0,0 +1,68 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package jscip; + +public class SCIP_EventObjChg { + private transient long swigCPtr; + protected transient boolean swigCMemOwn; + + protected SCIP_EventObjChg(long cPtr, boolean cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = cPtr; + } + + protected static long getCPtr(SCIP_EventObjChg obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + @SuppressWarnings("deprecation") + protected void finalize() { + delete(); + } + + public synchronized void delete() { + if (swigCPtr != 0) { + if (swigCMemOwn) { + swigCMemOwn = false; + SCIPJNIJNI.delete_SCIP_EventObjChg(swigCPtr); + } + swigCPtr = 0; + } + } + + public void setOldobj(double value) { + SCIPJNIJNI.SCIP_EventObjChg_oldobj_set(swigCPtr, this, value); + } + + public double getOldobj() { + return SCIPJNIJNI.SCIP_EventObjChg_oldobj_get(swigCPtr, this); + } + + public void setNewobj(double value) { + SCIPJNIJNI.SCIP_EventObjChg_newobj_set(swigCPtr, this, value); + } + + public double getNewobj() { + return SCIPJNIJNI.SCIP_EventObjChg_newobj_get(swigCPtr, this); + } + + public void setVar(SWIGTYPE_p_SCIP_VAR value) { + SCIPJNIJNI.SCIP_EventObjChg_var_set(swigCPtr, this, SWIGTYPE_p_SCIP_VAR.getCPtr(value)); + } + + public SWIGTYPE_p_SCIP_VAR getVar() { + long cPtr = SCIPJNIJNI.SCIP_EventObjChg_var_get(swigCPtr, this); + return (cPtr == 0) ? null : new SWIGTYPE_p_SCIP_VAR(cPtr, false); + } + + public SCIP_EventObjChg() { + this(SCIPJNIJNI.new_SCIP_EventObjChg(), true); + } + +} diff --git a/java/jscip/SCIP_EventRowAddedLP.java b/java/jscip/SCIP_EventRowAddedLP.java new file mode 100644 index 0000000..bce7faa --- /dev/null +++ b/java/jscip/SCIP_EventRowAddedLP.java @@ -0,0 +1,52 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package jscip; + +public class SCIP_EventRowAddedLP { + private transient long swigCPtr; + protected transient boolean swigCMemOwn; + + protected SCIP_EventRowAddedLP(long cPtr, boolean cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = cPtr; + } + + protected static long getCPtr(SCIP_EventRowAddedLP obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + @SuppressWarnings("deprecation") + protected void finalize() { + delete(); + } + + public synchronized void delete() { + if (swigCPtr != 0) { + if (swigCMemOwn) { + swigCMemOwn = false; + SCIPJNIJNI.delete_SCIP_EventRowAddedLP(swigCPtr); + } + swigCPtr = 0; + } + } + + public void setRow(SWIGTYPE_p_SCIP_ROW value) { + SCIPJNIJNI.SCIP_EventRowAddedLP_row_set(swigCPtr, this, SWIGTYPE_p_SCIP_ROW.getCPtr(value)); + } + + public SWIGTYPE_p_SCIP_ROW getRow() { + long cPtr = SCIPJNIJNI.SCIP_EventRowAddedLP_row_get(swigCPtr, this); + return (cPtr == 0) ? null : new SWIGTYPE_p_SCIP_ROW(cPtr, false); + } + + public SCIP_EventRowAddedLP() { + this(SCIPJNIJNI.new_SCIP_EventRowAddedLP(), true); + } + +} diff --git a/java/jscip/SCIP_EventRowAddedSepa.java b/java/jscip/SCIP_EventRowAddedSepa.java new file mode 100644 index 0000000..a7db03d --- /dev/null +++ b/java/jscip/SCIP_EventRowAddedSepa.java @@ -0,0 +1,52 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package jscip; + +public class SCIP_EventRowAddedSepa { + private transient long swigCPtr; + protected transient boolean swigCMemOwn; + + protected SCIP_EventRowAddedSepa(long cPtr, boolean cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = cPtr; + } + + protected static long getCPtr(SCIP_EventRowAddedSepa obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + @SuppressWarnings("deprecation") + protected void finalize() { + delete(); + } + + public synchronized void delete() { + if (swigCPtr != 0) { + if (swigCMemOwn) { + swigCMemOwn = false; + SCIPJNIJNI.delete_SCIP_EventRowAddedSepa(swigCPtr); + } + swigCPtr = 0; + } + } + + public void setRow(SWIGTYPE_p_SCIP_ROW value) { + SCIPJNIJNI.SCIP_EventRowAddedSepa_row_set(swigCPtr, this, SWIGTYPE_p_SCIP_ROW.getCPtr(value)); + } + + public SWIGTYPE_p_SCIP_ROW getRow() { + long cPtr = SCIPJNIJNI.SCIP_EventRowAddedSepa_row_get(swigCPtr, this); + return (cPtr == 0) ? null : new SWIGTYPE_p_SCIP_ROW(cPtr, false); + } + + public SCIP_EventRowAddedSepa() { + this(SCIPJNIJNI.new_SCIP_EventRowAddedSepa(), true); + } + +} diff --git a/java/jscip/SCIP_EventRowCoefChanged.java b/java/jscip/SCIP_EventRowCoefChanged.java new file mode 100644 index 0000000..941b9c2 --- /dev/null +++ b/java/jscip/SCIP_EventRowCoefChanged.java @@ -0,0 +1,77 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package jscip; + +public class SCIP_EventRowCoefChanged { + private transient long swigCPtr; + protected transient boolean swigCMemOwn; + + protected SCIP_EventRowCoefChanged(long cPtr, boolean cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = cPtr; + } + + protected static long getCPtr(SCIP_EventRowCoefChanged obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + @SuppressWarnings("deprecation") + protected void finalize() { + delete(); + } + + public synchronized void delete() { + if (swigCPtr != 0) { + if (swigCMemOwn) { + swigCMemOwn = false; + SCIPJNIJNI.delete_SCIP_EventRowCoefChanged(swigCPtr); + } + swigCPtr = 0; + } + } + + public void setRow(SWIGTYPE_p_SCIP_ROW value) { + SCIPJNIJNI.SCIP_EventRowCoefChanged_row_set(swigCPtr, this, SWIGTYPE_p_SCIP_ROW.getCPtr(value)); + } + + public SWIGTYPE_p_SCIP_ROW getRow() { + long cPtr = SCIPJNIJNI.SCIP_EventRowCoefChanged_row_get(swigCPtr, this); + return (cPtr == 0) ? null : new SWIGTYPE_p_SCIP_ROW(cPtr, false); + } + + public void setCol(SWIGTYPE_p_SCIP_COL value) { + SCIPJNIJNI.SCIP_EventRowCoefChanged_col_set(swigCPtr, this, SWIGTYPE_p_SCIP_COL.getCPtr(value)); + } + + public SWIGTYPE_p_SCIP_COL getCol() { + long cPtr = SCIPJNIJNI.SCIP_EventRowCoefChanged_col_get(swigCPtr, this); + return (cPtr == 0) ? null : new SWIGTYPE_p_SCIP_COL(cPtr, false); + } + + public void setOldval(double value) { + SCIPJNIJNI.SCIP_EventRowCoefChanged_oldval_set(swigCPtr, this, value); + } + + public double getOldval() { + return SCIPJNIJNI.SCIP_EventRowCoefChanged_oldval_get(swigCPtr, this); + } + + public void setNewval(double value) { + SCIPJNIJNI.SCIP_EventRowCoefChanged_newval_set(swigCPtr, this, value); + } + + public double getNewval() { + return SCIPJNIJNI.SCIP_EventRowCoefChanged_newval_get(swigCPtr, this); + } + + public SCIP_EventRowCoefChanged() { + this(SCIPJNIJNI.new_SCIP_EventRowCoefChanged(), true); + } + +} diff --git a/java/jscip/SCIP_EventRowConstChanged.java b/java/jscip/SCIP_EventRowConstChanged.java new file mode 100644 index 0000000..1092ec7 --- /dev/null +++ b/java/jscip/SCIP_EventRowConstChanged.java @@ -0,0 +1,68 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package jscip; + +public class SCIP_EventRowConstChanged { + private transient long swigCPtr; + protected transient boolean swigCMemOwn; + + protected SCIP_EventRowConstChanged(long cPtr, boolean cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = cPtr; + } + + protected static long getCPtr(SCIP_EventRowConstChanged obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + @SuppressWarnings("deprecation") + protected void finalize() { + delete(); + } + + public synchronized void delete() { + if (swigCPtr != 0) { + if (swigCMemOwn) { + swigCMemOwn = false; + SCIPJNIJNI.delete_SCIP_EventRowConstChanged(swigCPtr); + } + swigCPtr = 0; + } + } + + public void setRow(SWIGTYPE_p_SCIP_ROW value) { + SCIPJNIJNI.SCIP_EventRowConstChanged_row_set(swigCPtr, this, SWIGTYPE_p_SCIP_ROW.getCPtr(value)); + } + + public SWIGTYPE_p_SCIP_ROW getRow() { + long cPtr = SCIPJNIJNI.SCIP_EventRowConstChanged_row_get(swigCPtr, this); + return (cPtr == 0) ? null : new SWIGTYPE_p_SCIP_ROW(cPtr, false); + } + + public void setOldval(double value) { + SCIPJNIJNI.SCIP_EventRowConstChanged_oldval_set(swigCPtr, this, value); + } + + public double getOldval() { + return SCIPJNIJNI.SCIP_EventRowConstChanged_oldval_get(swigCPtr, this); + } + + public void setNewval(double value) { + SCIPJNIJNI.SCIP_EventRowConstChanged_newval_set(swigCPtr, this, value); + } + + public double getNewval() { + return SCIPJNIJNI.SCIP_EventRowConstChanged_newval_get(swigCPtr, this); + } + + public SCIP_EventRowConstChanged() { + this(SCIPJNIJNI.new_SCIP_EventRowConstChanged(), true); + } + +} diff --git a/java/jscip/SCIP_EventRowDeletedLP.java b/java/jscip/SCIP_EventRowDeletedLP.java new file mode 100644 index 0000000..8ab42cd --- /dev/null +++ b/java/jscip/SCIP_EventRowDeletedLP.java @@ -0,0 +1,52 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package jscip; + +public class SCIP_EventRowDeletedLP { + private transient long swigCPtr; + protected transient boolean swigCMemOwn; + + protected SCIP_EventRowDeletedLP(long cPtr, boolean cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = cPtr; + } + + protected static long getCPtr(SCIP_EventRowDeletedLP obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + @SuppressWarnings("deprecation") + protected void finalize() { + delete(); + } + + public synchronized void delete() { + if (swigCPtr != 0) { + if (swigCMemOwn) { + swigCMemOwn = false; + SCIPJNIJNI.delete_SCIP_EventRowDeletedLP(swigCPtr); + } + swigCPtr = 0; + } + } + + public void setRow(SWIGTYPE_p_SCIP_ROW value) { + SCIPJNIJNI.SCIP_EventRowDeletedLP_row_set(swigCPtr, this, SWIGTYPE_p_SCIP_ROW.getCPtr(value)); + } + + public SWIGTYPE_p_SCIP_ROW getRow() { + long cPtr = SCIPJNIJNI.SCIP_EventRowDeletedLP_row_get(swigCPtr, this); + return (cPtr == 0) ? null : new SWIGTYPE_p_SCIP_ROW(cPtr, false); + } + + public SCIP_EventRowDeletedLP() { + this(SCIPJNIJNI.new_SCIP_EventRowDeletedLP(), true); + } + +} diff --git a/java/jscip/SCIP_EventRowDeletedSepa.java b/java/jscip/SCIP_EventRowDeletedSepa.java new file mode 100644 index 0000000..dbbe88b --- /dev/null +++ b/java/jscip/SCIP_EventRowDeletedSepa.java @@ -0,0 +1,52 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package jscip; + +public class SCIP_EventRowDeletedSepa { + private transient long swigCPtr; + protected transient boolean swigCMemOwn; + + protected SCIP_EventRowDeletedSepa(long cPtr, boolean cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = cPtr; + } + + protected static long getCPtr(SCIP_EventRowDeletedSepa obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + @SuppressWarnings("deprecation") + protected void finalize() { + delete(); + } + + public synchronized void delete() { + if (swigCPtr != 0) { + if (swigCMemOwn) { + swigCMemOwn = false; + SCIPJNIJNI.delete_SCIP_EventRowDeletedSepa(swigCPtr); + } + swigCPtr = 0; + } + } + + public void setRow(SWIGTYPE_p_SCIP_ROW value) { + SCIPJNIJNI.SCIP_EventRowDeletedSepa_row_set(swigCPtr, this, SWIGTYPE_p_SCIP_ROW.getCPtr(value)); + } + + public SWIGTYPE_p_SCIP_ROW getRow() { + long cPtr = SCIPJNIJNI.SCIP_EventRowDeletedSepa_row_get(swigCPtr, this); + return (cPtr == 0) ? null : new SWIGTYPE_p_SCIP_ROW(cPtr, false); + } + + public SCIP_EventRowDeletedSepa() { + this(SCIPJNIJNI.new_SCIP_EventRowDeletedSepa(), true); + } + +} diff --git a/java/jscip/SCIP_EventRowSideChanged.java b/java/jscip/SCIP_EventRowSideChanged.java new file mode 100644 index 0000000..aa9ab10 --- /dev/null +++ b/java/jscip/SCIP_EventRowSideChanged.java @@ -0,0 +1,76 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package jscip; + +public class SCIP_EventRowSideChanged { + private transient long swigCPtr; + protected transient boolean swigCMemOwn; + + protected SCIP_EventRowSideChanged(long cPtr, boolean cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = cPtr; + } + + protected static long getCPtr(SCIP_EventRowSideChanged obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + @SuppressWarnings("deprecation") + protected void finalize() { + delete(); + } + + public synchronized void delete() { + if (swigCPtr != 0) { + if (swigCMemOwn) { + swigCMemOwn = false; + SCIPJNIJNI.delete_SCIP_EventRowSideChanged(swigCPtr); + } + swigCPtr = 0; + } + } + + public void setRow(SWIGTYPE_p_SCIP_ROW value) { + SCIPJNIJNI.SCIP_EventRowSideChanged_row_set(swigCPtr, this, SWIGTYPE_p_SCIP_ROW.getCPtr(value)); + } + + public SWIGTYPE_p_SCIP_ROW getRow() { + long cPtr = SCIPJNIJNI.SCIP_EventRowSideChanged_row_get(swigCPtr, this); + return (cPtr == 0) ? null : new SWIGTYPE_p_SCIP_ROW(cPtr, false); + } + + public void setSide(SWIGTYPE_p_SCIP_SIDETYPE value) { + SCIPJNIJNI.SCIP_EventRowSideChanged_side_set(swigCPtr, this, SWIGTYPE_p_SCIP_SIDETYPE.getCPtr(value)); + } + + public SWIGTYPE_p_SCIP_SIDETYPE getSide() { + return new SWIGTYPE_p_SCIP_SIDETYPE(SCIPJNIJNI.SCIP_EventRowSideChanged_side_get(swigCPtr, this), true); + } + + public void setOldval(double value) { + SCIPJNIJNI.SCIP_EventRowSideChanged_oldval_set(swigCPtr, this, value); + } + + public double getOldval() { + return SCIPJNIJNI.SCIP_EventRowSideChanged_oldval_get(swigCPtr, this); + } + + public void setNewval(double value) { + SCIPJNIJNI.SCIP_EventRowSideChanged_newval_set(swigCPtr, this, value); + } + + public double getNewval() { + return SCIPJNIJNI.SCIP_EventRowSideChanged_newval_get(swigCPtr, this); + } + + public SCIP_EventRowSideChanged() { + this(SCIPJNIJNI.new_SCIP_EventRowSideChanged(), true); + } + +} diff --git a/java/jscip/SCIP_EventTypeChg.java b/java/jscip/SCIP_EventTypeChg.java new file mode 100644 index 0000000..8f3a70c --- /dev/null +++ b/java/jscip/SCIP_EventTypeChg.java @@ -0,0 +1,68 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package jscip; + +public class SCIP_EventTypeChg { + private transient long swigCPtr; + protected transient boolean swigCMemOwn; + + protected SCIP_EventTypeChg(long cPtr, boolean cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = cPtr; + } + + protected static long getCPtr(SCIP_EventTypeChg obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + @SuppressWarnings("deprecation") + protected void finalize() { + delete(); + } + + public synchronized void delete() { + if (swigCPtr != 0) { + if (swigCMemOwn) { + swigCMemOwn = false; + SCIPJNIJNI.delete_SCIP_EventTypeChg(swigCPtr); + } + swigCPtr = 0; + } + } + + public void setOldtype(SCIP_Vartype value) { + SCIPJNIJNI.SCIP_EventTypeChg_oldtype_set(swigCPtr, this, value.swigValue()); + } + + public SCIP_Vartype getOldtype() { + return SCIP_Vartype.swigToEnum(SCIPJNIJNI.SCIP_EventTypeChg_oldtype_get(swigCPtr, this)); + } + + public void setNewtype(SCIP_Vartype value) { + SCIPJNIJNI.SCIP_EventTypeChg_newtype_set(swigCPtr, this, value.swigValue()); + } + + public SCIP_Vartype getNewtype() { + return SCIP_Vartype.swigToEnum(SCIPJNIJNI.SCIP_EventTypeChg_newtype_get(swigCPtr, this)); + } + + public void setVar(SWIGTYPE_p_SCIP_VAR value) { + SCIPJNIJNI.SCIP_EventTypeChg_var_set(swigCPtr, this, SWIGTYPE_p_SCIP_VAR.getCPtr(value)); + } + + public SWIGTYPE_p_SCIP_VAR getVar() { + long cPtr = SCIPJNIJNI.SCIP_EventTypeChg_var_get(swigCPtr, this); + return (cPtr == 0) ? null : new SWIGTYPE_p_SCIP_VAR(cPtr, false); + } + + public SCIP_EventTypeChg() { + this(SCIPJNIJNI.new_SCIP_EventTypeChg(), true); + } + +} diff --git a/java/jscip/SCIP_EventVarAdded.java b/java/jscip/SCIP_EventVarAdded.java new file mode 100644 index 0000000..a521068 --- /dev/null +++ b/java/jscip/SCIP_EventVarAdded.java @@ -0,0 +1,52 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package jscip; + +public class SCIP_EventVarAdded { + private transient long swigCPtr; + protected transient boolean swigCMemOwn; + + protected SCIP_EventVarAdded(long cPtr, boolean cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = cPtr; + } + + protected static long getCPtr(SCIP_EventVarAdded obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + @SuppressWarnings("deprecation") + protected void finalize() { + delete(); + } + + public synchronized void delete() { + if (swigCPtr != 0) { + if (swigCMemOwn) { + swigCMemOwn = false; + SCIPJNIJNI.delete_SCIP_EventVarAdded(swigCPtr); + } + swigCPtr = 0; + } + } + + public void setVar(SWIGTYPE_p_SCIP_VAR value) { + SCIPJNIJNI.SCIP_EventVarAdded_var_set(swigCPtr, this, SWIGTYPE_p_SCIP_VAR.getCPtr(value)); + } + + public SWIGTYPE_p_SCIP_VAR getVar() { + long cPtr = SCIPJNIJNI.SCIP_EventVarAdded_var_get(swigCPtr, this); + return (cPtr == 0) ? null : new SWIGTYPE_p_SCIP_VAR(cPtr, false); + } + + public SCIP_EventVarAdded() { + this(SCIPJNIJNI.new_SCIP_EventVarAdded(), true); + } + +} diff --git a/java/jscip/SCIP_EventVarDeleted.java b/java/jscip/SCIP_EventVarDeleted.java new file mode 100644 index 0000000..36a9872 --- /dev/null +++ b/java/jscip/SCIP_EventVarDeleted.java @@ -0,0 +1,52 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package jscip; + +public class SCIP_EventVarDeleted { + private transient long swigCPtr; + protected transient boolean swigCMemOwn; + + protected SCIP_EventVarDeleted(long cPtr, boolean cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = cPtr; + } + + protected static long getCPtr(SCIP_EventVarDeleted obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + @SuppressWarnings("deprecation") + protected void finalize() { + delete(); + } + + public synchronized void delete() { + if (swigCPtr != 0) { + if (swigCMemOwn) { + swigCMemOwn = false; + SCIPJNIJNI.delete_SCIP_EventVarDeleted(swigCPtr); + } + swigCPtr = 0; + } + } + + public void setVar(SWIGTYPE_p_SCIP_VAR value) { + SCIPJNIJNI.SCIP_EventVarDeleted_var_set(swigCPtr, this, SWIGTYPE_p_SCIP_VAR.getCPtr(value)); + } + + public SWIGTYPE_p_SCIP_VAR getVar() { + long cPtr = SCIPJNIJNI.SCIP_EventVarDeleted_var_get(swigCPtr, this); + return (cPtr == 0) ? null : new SWIGTYPE_p_SCIP_VAR(cPtr, false); + } + + public SCIP_EventVarDeleted() { + this(SCIPJNIJNI.new_SCIP_EventVarDeleted(), true); + } + +} diff --git a/java/jscip/SCIP_EventVarFixed.java b/java/jscip/SCIP_EventVarFixed.java new file mode 100644 index 0000000..1aab75e --- /dev/null +++ b/java/jscip/SCIP_EventVarFixed.java @@ -0,0 +1,52 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package jscip; + +public class SCIP_EventVarFixed { + private transient long swigCPtr; + protected transient boolean swigCMemOwn; + + protected SCIP_EventVarFixed(long cPtr, boolean cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = cPtr; + } + + protected static long getCPtr(SCIP_EventVarFixed obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + @SuppressWarnings("deprecation") + protected void finalize() { + delete(); + } + + public synchronized void delete() { + if (swigCPtr != 0) { + if (swigCMemOwn) { + swigCMemOwn = false; + SCIPJNIJNI.delete_SCIP_EventVarFixed(swigCPtr); + } + swigCPtr = 0; + } + } + + public void setVar(SWIGTYPE_p_SCIP_VAR value) { + SCIPJNIJNI.SCIP_EventVarFixed_var_set(swigCPtr, this, SWIGTYPE_p_SCIP_VAR.getCPtr(value)); + } + + public SWIGTYPE_p_SCIP_VAR getVar() { + long cPtr = SCIPJNIJNI.SCIP_EventVarFixed_var_get(swigCPtr, this); + return (cPtr == 0) ? null : new SWIGTYPE_p_SCIP_VAR(cPtr, false); + } + + public SCIP_EventVarFixed() { + this(SCIPJNIJNI.new_SCIP_EventVarFixed(), true); + } + +} diff --git a/java/jscip/SCIP_EventVarUnlocked.java b/java/jscip/SCIP_EventVarUnlocked.java new file mode 100644 index 0000000..9ab866b --- /dev/null +++ b/java/jscip/SCIP_EventVarUnlocked.java @@ -0,0 +1,52 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package jscip; + +public class SCIP_EventVarUnlocked { + private transient long swigCPtr; + protected transient boolean swigCMemOwn; + + protected SCIP_EventVarUnlocked(long cPtr, boolean cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = cPtr; + } + + protected static long getCPtr(SCIP_EventVarUnlocked obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + @SuppressWarnings("deprecation") + protected void finalize() { + delete(); + } + + public synchronized void delete() { + if (swigCPtr != 0) { + if (swigCMemOwn) { + swigCMemOwn = false; + SCIPJNIJNI.delete_SCIP_EventVarUnlocked(swigCPtr); + } + swigCPtr = 0; + } + } + + public void setVar(SWIGTYPE_p_SCIP_VAR value) { + SCIPJNIJNI.SCIP_EventVarUnlocked_var_set(swigCPtr, this, SWIGTYPE_p_SCIP_VAR.getCPtr(value)); + } + + public SWIGTYPE_p_SCIP_VAR getVar() { + long cPtr = SCIPJNIJNI.SCIP_EventVarUnlocked_var_get(swigCPtr, this); + return (cPtr == 0) ? null : new SWIGTYPE_p_SCIP_VAR(cPtr, false); + } + + public SCIP_EventVarUnlocked() { + this(SCIPJNIJNI.new_SCIP_EventVarUnlocked(), true); + } + +} diff --git a/java/jscip/SCIP_LockType.java b/java/jscip/SCIP_LockType.java new file mode 100644 index 0000000..6bbbc9c --- /dev/null +++ b/java/jscip/SCIP_LockType.java @@ -0,0 +1,54 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package jscip; + +public final class SCIP_LockType { + public final static SCIP_LockType SCIP_LOCKTYPE_MODEL = new SCIP_LockType("SCIP_LOCKTYPE_MODEL", SCIPJNIJNI.SCIP_LOCKTYPE_MODEL_get()); + public final static SCIP_LockType SCIP_LOCKTYPE_CONFLICT = new SCIP_LockType("SCIP_LOCKTYPE_CONFLICT", SCIPJNIJNI.SCIP_LOCKTYPE_CONFLICT_get()); + + public final int swigValue() { + return swigValue; + } + + public String toString() { + return swigName; + } + + public static SCIP_LockType swigToEnum(int swigValue) { + if (swigValue < swigValues.length && swigValue >= 0 && swigValues[swigValue].swigValue == swigValue) + return swigValues[swigValue]; + for (int i = 0; i < swigValues.length; i++) + if (swigValues[i].swigValue == swigValue) + return swigValues[i]; + throw new IllegalArgumentException("No enum " + SCIP_LockType.class + " with value " + swigValue); + } + + private SCIP_LockType(String swigName) { + this.swigName = swigName; + this.swigValue = swigNext++; + } + + private SCIP_LockType(String swigName, int swigValue) { + this.swigName = swigName; + this.swigValue = swigValue; + swigNext = swigValue+1; + } + + private SCIP_LockType(String swigName, SCIP_LockType swigEnum) { + this.swigName = swigName; + this.swigValue = swigEnum.swigValue; + swigNext = this.swigValue+1; + } + + private static SCIP_LockType[] swigValues = { SCIP_LOCKTYPE_MODEL, SCIP_LOCKTYPE_CONFLICT }; + private static int swigNext = 0; + private final int swigValue; + private final String swigName; +} + diff --git a/java/jscip/SCIP_ParamSetting.java b/java/jscip/SCIP_ParamSetting.java index f41a466..53e989f 100644 --- a/java/jscip/SCIP_ParamSetting.java +++ b/java/jscip/SCIP_ParamSetting.java @@ -1,8 +1,8 @@ /* ---------------------------------------------------------------------------- - * This file was automatically generated by SWIG (https://www.swig.org). - * Version 4.2.0 + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 * - * Do not make changes to this file unless you know what you are doing - modify + * Do not make changes to this file unless you know what you are doing--modify * the SWIG interface file instead. * ----------------------------------------------------------------------------- */ diff --git a/java/jscip/SCIP_Result.java b/java/jscip/SCIP_Result.java new file mode 100644 index 0000000..9ac2439 --- /dev/null +++ b/java/jscip/SCIP_Result.java @@ -0,0 +1,70 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package jscip; + +public final class SCIP_Result { + public final static SCIP_Result SCIP_DIDNOTRUN = new SCIP_Result("SCIP_DIDNOTRUN", SCIPJNIJNI.SCIP_DIDNOTRUN_get()); + public final static SCIP_Result SCIP_DELAYED = new SCIP_Result("SCIP_DELAYED", SCIPJNIJNI.SCIP_DELAYED_get()); + public final static SCIP_Result SCIP_DIDNOTFIND = new SCIP_Result("SCIP_DIDNOTFIND", SCIPJNIJNI.SCIP_DIDNOTFIND_get()); + public final static SCIP_Result SCIP_FEASIBLE = new SCIP_Result("SCIP_FEASIBLE", SCIPJNIJNI.SCIP_FEASIBLE_get()); + public final static SCIP_Result SCIP_INFEASIBLE = new SCIP_Result("SCIP_INFEASIBLE", SCIPJNIJNI.SCIP_INFEASIBLE_get()); + public final static SCIP_Result SCIP_UNBOUNDED = new SCIP_Result("SCIP_UNBOUNDED", SCIPJNIJNI.SCIP_UNBOUNDED_get()); + public final static SCIP_Result SCIP_CUTOFF = new SCIP_Result("SCIP_CUTOFF", SCIPJNIJNI.SCIP_CUTOFF_get()); + public final static SCIP_Result SCIP_SEPARATED = new SCIP_Result("SCIP_SEPARATED", SCIPJNIJNI.SCIP_SEPARATED_get()); + public final static SCIP_Result SCIP_NEWROUND = new SCIP_Result("SCIP_NEWROUND", SCIPJNIJNI.SCIP_NEWROUND_get()); + public final static SCIP_Result SCIP_REDUCEDDOM = new SCIP_Result("SCIP_REDUCEDDOM", SCIPJNIJNI.SCIP_REDUCEDDOM_get()); + public final static SCIP_Result SCIP_CONSADDED = new SCIP_Result("SCIP_CONSADDED", SCIPJNIJNI.SCIP_CONSADDED_get()); + public final static SCIP_Result SCIP_CONSCHANGED = new SCIP_Result("SCIP_CONSCHANGED", SCIPJNIJNI.SCIP_CONSCHANGED_get()); + public final static SCIP_Result SCIP_BRANCHED = new SCIP_Result("SCIP_BRANCHED", SCIPJNIJNI.SCIP_BRANCHED_get()); + public final static SCIP_Result SCIP_SOLVELP = new SCIP_Result("SCIP_SOLVELP", SCIPJNIJNI.SCIP_SOLVELP_get()); + public final static SCIP_Result SCIP_FOUNDSOL = new SCIP_Result("SCIP_FOUNDSOL", SCIPJNIJNI.SCIP_FOUNDSOL_get()); + public final static SCIP_Result SCIP_SUSPENDED = new SCIP_Result("SCIP_SUSPENDED", SCIPJNIJNI.SCIP_SUSPENDED_get()); + public final static SCIP_Result SCIP_SUCCESS = new SCIP_Result("SCIP_SUCCESS", SCIPJNIJNI.SCIP_SUCCESS_get()); + public final static SCIP_Result SCIP_DELAYNODE = new SCIP_Result("SCIP_DELAYNODE", SCIPJNIJNI.SCIP_DELAYNODE_get()); + + public final int swigValue() { + return swigValue; + } + + public String toString() { + return swigName; + } + + public static SCIP_Result swigToEnum(int swigValue) { + if (swigValue < swigValues.length && swigValue >= 0 && swigValues[swigValue].swigValue == swigValue) + return swigValues[swigValue]; + for (int i = 0; i < swigValues.length; i++) + if (swigValues[i].swigValue == swigValue) + return swigValues[i]; + throw new IllegalArgumentException("No enum " + SCIP_Result.class + " with value " + swigValue); + } + + private SCIP_Result(String swigName) { + this.swigName = swigName; + this.swigValue = swigNext++; + } + + private SCIP_Result(String swigName, int swigValue) { + this.swigName = swigName; + this.swigValue = swigValue; + swigNext = swigValue+1; + } + + private SCIP_Result(String swigName, SCIP_Result swigEnum) { + this.swigName = swigName; + this.swigValue = swigEnum.swigValue; + swigNext = this.swigValue+1; + } + + private static SCIP_Result[] swigValues = { SCIP_DIDNOTRUN, SCIP_DELAYED, SCIP_DIDNOTFIND, SCIP_FEASIBLE, SCIP_INFEASIBLE, SCIP_UNBOUNDED, SCIP_CUTOFF, SCIP_SEPARATED, SCIP_NEWROUND, SCIP_REDUCEDDOM, SCIP_CONSADDED, SCIP_CONSCHANGED, SCIP_BRANCHED, SCIP_SOLVELP, SCIP_FOUNDSOL, SCIP_SUSPENDED, SCIP_SUCCESS, SCIP_DELAYNODE }; + private static int swigNext = 0; + private final int swigValue; + private final String swigName; +} + diff --git a/java/jscip/SWIGTYPE_p_SCIP_BDCHGIDX.java b/java/jscip/SWIGTYPE_p_SCIP_BDCHGIDX.java new file mode 100644 index 0000000..e5a8bce --- /dev/null +++ b/java/jscip/SWIGTYPE_p_SCIP_BDCHGIDX.java @@ -0,0 +1,26 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package jscip; + +public class SWIGTYPE_p_SCIP_BDCHGIDX { + private transient long swigCPtr; + + protected SWIGTYPE_p_SCIP_BDCHGIDX(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_SCIP_BDCHGIDX() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_SCIP_BDCHGIDX obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} + diff --git a/java/jscip/SWIGTYPE_p_SCIP_COL.java b/java/jscip/SWIGTYPE_p_SCIP_COL.java new file mode 100644 index 0000000..e509ea8 --- /dev/null +++ b/java/jscip/SWIGTYPE_p_SCIP_COL.java @@ -0,0 +1,26 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package jscip; + +public class SWIGTYPE_p_SCIP_COL { + private transient long swigCPtr; + + protected SWIGTYPE_p_SCIP_COL(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_SCIP_COL() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_SCIP_COL obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} + diff --git a/java/jscip/SWIGTYPE_p_SCIP_CONSHDLR.java b/java/jscip/SWIGTYPE_p_SCIP_CONSHDLR.java new file mode 100644 index 0000000..5fbe507 --- /dev/null +++ b/java/jscip/SWIGTYPE_p_SCIP_CONSHDLR.java @@ -0,0 +1,26 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package jscip; + +public class SWIGTYPE_p_SCIP_CONSHDLR { + private transient long swigCPtr; + + protected SWIGTYPE_p_SCIP_CONSHDLR(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_SCIP_CONSHDLR() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_SCIP_CONSHDLR obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} + diff --git a/java/jscip/SWIGTYPE_p_SCIP_DIVESET.java b/java/jscip/SWIGTYPE_p_SCIP_DIVESET.java new file mode 100644 index 0000000..b9d2ef4 --- /dev/null +++ b/java/jscip/SWIGTYPE_p_SCIP_DIVESET.java @@ -0,0 +1,26 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package jscip; + +public class SWIGTYPE_p_SCIP_DIVESET { + private transient long swigCPtr; + + protected SWIGTYPE_p_SCIP_DIVESET(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_SCIP_DIVESET() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_SCIP_DIVESET obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} + diff --git a/java/jscip/SWIGTYPE_p_SCIP_EVENT.java b/java/jscip/SWIGTYPE_p_SCIP_EVENT.java new file mode 100644 index 0000000..381341c --- /dev/null +++ b/java/jscip/SWIGTYPE_p_SCIP_EVENT.java @@ -0,0 +1,26 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package jscip; + +public class SWIGTYPE_p_SCIP_EVENT { + private transient long swigCPtr; + + protected SWIGTYPE_p_SCIP_EVENT(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_SCIP_EVENT() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_SCIP_EVENT obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} + diff --git a/java/jscip/SWIGTYPE_p_SCIP_EVENTDATA.java b/java/jscip/SWIGTYPE_p_SCIP_EVENTDATA.java new file mode 100644 index 0000000..e4a2c1d --- /dev/null +++ b/java/jscip/SWIGTYPE_p_SCIP_EVENTDATA.java @@ -0,0 +1,26 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package jscip; + +public class SWIGTYPE_p_SCIP_EVENTDATA { + private transient long swigCPtr; + + protected SWIGTYPE_p_SCIP_EVENTDATA(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_SCIP_EVENTDATA() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_SCIP_EVENTDATA obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} + diff --git a/java/jscip/SWIGTYPE_p_SCIP_EVENTHDLR.java b/java/jscip/SWIGTYPE_p_SCIP_EVENTHDLR.java new file mode 100644 index 0000000..afe9057 --- /dev/null +++ b/java/jscip/SWIGTYPE_p_SCIP_EVENTHDLR.java @@ -0,0 +1,26 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package jscip; + +public class SWIGTYPE_p_SCIP_EVENTHDLR { + private transient long swigCPtr; + + protected SWIGTYPE_p_SCIP_EVENTHDLR(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_SCIP_EVENTHDLR() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_SCIP_EVENTHDLR obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} + diff --git a/java/jscip/SWIGTYPE_p_SCIP_EVENTTYPE.java b/java/jscip/SWIGTYPE_p_SCIP_EVENTTYPE.java new file mode 100644 index 0000000..0597c36 --- /dev/null +++ b/java/jscip/SWIGTYPE_p_SCIP_EVENTTYPE.java @@ -0,0 +1,26 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package jscip; + +public class SWIGTYPE_p_SCIP_EVENTTYPE { + private transient long swigCPtr; + + protected SWIGTYPE_p_SCIP_EVENTTYPE(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_SCIP_EVENTTYPE() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_SCIP_EVENTTYPE obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} + diff --git a/java/jscip/SWIGTYPE_p_SCIP_EventData.java b/java/jscip/SWIGTYPE_p_SCIP_EventData.java new file mode 100644 index 0000000..04c6a0c --- /dev/null +++ b/java/jscip/SWIGTYPE_p_SCIP_EventData.java @@ -0,0 +1,26 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package jscip; + +public class SWIGTYPE_p_SCIP_EventData { + private transient long swigCPtr; + + protected SWIGTYPE_p_SCIP_EventData(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_SCIP_EventData() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_SCIP_EventData obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} + diff --git a/java/jscip/SWIGTYPE_p_SCIP_Eventhdlr.java b/java/jscip/SWIGTYPE_p_SCIP_Eventhdlr.java new file mode 100644 index 0000000..d234661 --- /dev/null +++ b/java/jscip/SWIGTYPE_p_SCIP_Eventhdlr.java @@ -0,0 +1,26 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package jscip; + +public class SWIGTYPE_p_SCIP_Eventhdlr { + private transient long swigCPtr; + + protected SWIGTYPE_p_SCIP_Eventhdlr(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_SCIP_Eventhdlr() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_SCIP_Eventhdlr obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} + diff --git a/java/jscip/SWIGTYPE_p_SCIP_HASHMAP.java b/java/jscip/SWIGTYPE_p_SCIP_HASHMAP.java new file mode 100644 index 0000000..892296d --- /dev/null +++ b/java/jscip/SWIGTYPE_p_SCIP_HASHMAP.java @@ -0,0 +1,26 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package jscip; + +public class SWIGTYPE_p_SCIP_HASHMAP { + private transient long swigCPtr; + + protected SWIGTYPE_p_SCIP_HASHMAP(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_SCIP_HASHMAP() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_SCIP_HASHMAP obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} + diff --git a/java/jscip/SWIGTYPE_p_SCIP_LOCKTYPE.java b/java/jscip/SWIGTYPE_p_SCIP_LOCKTYPE.java new file mode 100644 index 0000000..a76fb7a --- /dev/null +++ b/java/jscip/SWIGTYPE_p_SCIP_LOCKTYPE.java @@ -0,0 +1,26 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package jscip; + +public class SWIGTYPE_p_SCIP_LOCKTYPE { + private transient long swigCPtr; + + protected SWIGTYPE_p_SCIP_LOCKTYPE(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_SCIP_LOCKTYPE() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_SCIP_LOCKTYPE obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} + diff --git a/java/jscip/SWIGTYPE_p_SCIP_NODE.java b/java/jscip/SWIGTYPE_p_SCIP_NODE.java new file mode 100644 index 0000000..61b5c71 --- /dev/null +++ b/java/jscip/SWIGTYPE_p_SCIP_NODE.java @@ -0,0 +1,26 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package jscip; + +public class SWIGTYPE_p_SCIP_NODE { + private transient long swigCPtr; + + protected SWIGTYPE_p_SCIP_NODE(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_SCIP_NODE() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_SCIP_NODE obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} + diff --git a/java/jscip/SWIGTYPE_p_SCIP_PRESOLTIMING.java b/java/jscip/SWIGTYPE_p_SCIP_PRESOLTIMING.java new file mode 100644 index 0000000..9893ea8 --- /dev/null +++ b/java/jscip/SWIGTYPE_p_SCIP_PRESOLTIMING.java @@ -0,0 +1,26 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package jscip; + +public class SWIGTYPE_p_SCIP_PRESOLTIMING { + private transient long swigCPtr; + + protected SWIGTYPE_p_SCIP_PRESOLTIMING(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_SCIP_PRESOLTIMING() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_SCIP_PRESOLTIMING obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} + diff --git a/java/jscip/SWIGTYPE_p_SCIP_PROPTIMING.java b/java/jscip/SWIGTYPE_p_SCIP_PROPTIMING.java new file mode 100644 index 0000000..3b49e80 --- /dev/null +++ b/java/jscip/SWIGTYPE_p_SCIP_PROPTIMING.java @@ -0,0 +1,26 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package jscip; + +public class SWIGTYPE_p_SCIP_PROPTIMING { + private transient long swigCPtr; + + protected SWIGTYPE_p_SCIP_PROPTIMING(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_SCIP_PROPTIMING() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_SCIP_PROPTIMING obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} + diff --git a/java/jscip/SWIGTYPE_p_SCIP_ROW.java b/java/jscip/SWIGTYPE_p_SCIP_ROW.java new file mode 100644 index 0000000..6a65962 --- /dev/null +++ b/java/jscip/SWIGTYPE_p_SCIP_ROW.java @@ -0,0 +1,26 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package jscip; + +public class SWIGTYPE_p_SCIP_ROW { + private transient long swigCPtr; + + protected SWIGTYPE_p_SCIP_ROW(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_SCIP_ROW() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_SCIP_ROW obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} + diff --git a/java/jscip/SWIGTYPE_p_SCIP_Result.java b/java/jscip/SWIGTYPE_p_SCIP_Result.java new file mode 100644 index 0000000..e524acc --- /dev/null +++ b/java/jscip/SWIGTYPE_p_SCIP_Result.java @@ -0,0 +1,26 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package jscip; + +public class SWIGTYPE_p_SCIP_Result { + private transient long swigCPtr; + + protected SWIGTYPE_p_SCIP_Result(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_SCIP_Result() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_SCIP_Result obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} + diff --git a/java/jscip/SWIGTYPE_p_SCIP_SIDETYPE.java b/java/jscip/SWIGTYPE_p_SCIP_SIDETYPE.java new file mode 100644 index 0000000..26fcbe5 --- /dev/null +++ b/java/jscip/SWIGTYPE_p_SCIP_SIDETYPE.java @@ -0,0 +1,26 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package jscip; + +public class SWIGTYPE_p_SCIP_SIDETYPE { + private transient long swigCPtr; + + protected SWIGTYPE_p_SCIP_SIDETYPE(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_SCIP_SIDETYPE() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_SCIP_SIDETYPE obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} + diff --git a/java/jscip/SWIGTYPE_p_SYM_GRAPH.java b/java/jscip/SWIGTYPE_p_SYM_GRAPH.java new file mode 100644 index 0000000..3dd5dad --- /dev/null +++ b/java/jscip/SWIGTYPE_p_SYM_GRAPH.java @@ -0,0 +1,26 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package jscip; + +public class SWIGTYPE_p_SYM_GRAPH { + private transient long swigCPtr; + + protected SWIGTYPE_p_SYM_GRAPH(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_SYM_GRAPH() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_SYM_GRAPH obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} + diff --git a/java/jscip/SWIGTYPE_p_p_SCIP_CONSDATA.java b/java/jscip/SWIGTYPE_p_p_SCIP_CONSDATA.java new file mode 100644 index 0000000..17094ab --- /dev/null +++ b/java/jscip/SWIGTYPE_p_p_SCIP_CONSDATA.java @@ -0,0 +1,26 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package jscip; + +public class SWIGTYPE_p_p_SCIP_CONSDATA { + private transient long swigCPtr; + + protected SWIGTYPE_p_p_SCIP_CONSDATA(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_p_SCIP_CONSDATA() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_p_SCIP_CONSDATA obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} + diff --git a/java/jscip/SWIGTYPE_p_p_SCIP_EVENTDATA.java b/java/jscip/SWIGTYPE_p_p_SCIP_EVENTDATA.java new file mode 100644 index 0000000..84753bc --- /dev/null +++ b/java/jscip/SWIGTYPE_p_p_SCIP_EVENTDATA.java @@ -0,0 +1,26 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package jscip; + +public class SWIGTYPE_p_p_SCIP_EVENTDATA { + private transient long swigCPtr; + + protected SWIGTYPE_p_p_SCIP_EVENTDATA(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_p_SCIP_EVENTDATA() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_p_SCIP_EVENTDATA obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} + diff --git a/java/jscip/SWIGTYPE_p_uint64_t.java b/java/jscip/SWIGTYPE_p_uint64_t.java new file mode 100644 index 0000000..39b23c5 --- /dev/null +++ b/java/jscip/SWIGTYPE_p_uint64_t.java @@ -0,0 +1,26 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.2 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package jscip; + +public class SWIGTYPE_p_uint64_t { + private transient long swigCPtr; + + protected SWIGTYPE_p_uint64_t(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_uint64_t() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_uint64_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} + diff --git a/java/jscip/Scip.java b/java/jscip/Scip.java index 0a39a0a..bc6dc3c 100644 --- a/java/jscip/Scip.java +++ b/java/jscip/Scip.java @@ -1491,10 +1491,10 @@ public Solution[] getSols() /** wraps SCIPgetSolVal() */ public double getSolVal(Solution sol, Variable var) { - assert(sol != null && sol.getPtr() != null); + //assert(sol != null && sol.getPtr() != null); // it is valid during constraint handler enfops execution to pass null assert(var != null && var.getPtr() != null); - return SCIPJNI.SCIPgetSolVal(_scipptr, sol.getPtr(), var.getPtr()); + return SCIPJNI.SCIPgetSolVal(_scipptr, sol == null ? null : sol.getPtr(), var.getPtr()); } /** wraps SCIPgetSolOrigObj() */ @@ -1689,4 +1689,13 @@ public void setMessagehdlrLogfile(String filename) { public SCIP_VerbLevel getVerbLevel() { return SCIPJNI.SCIPgetVerbLevel(_scipptr); } + + public void addEventHandler(EventHandler eventHandler) { + eventHandler.attach(this, _scipptr); + } + + public void addConstraintHandler(ConstraintHandler constraintHandler) { + constraintHandler.attach(this, _scipptr); + } + } diff --git a/java/jscip/ScipPresolTiming.java b/java/jscip/ScipPresolTiming.java new file mode 100644 index 0000000..878bb51 --- /dev/null +++ b/java/jscip/ScipPresolTiming.java @@ -0,0 +1,13 @@ +package jscip; + +public class ScipPresolTiming { + + public static final int NONE = 0x002; + public static final int FAST = 0x004; + public static final int MEDIUM = 0x008; + public static final int EXHAUSTIVE = 0x010; + public static final int FINAL = 0x020; + public static final int ALWAYS = FAST | MEDIUM | EXHAUSTIVE; + public static final int MAX = FAST | MEDIUM | EXHAUSTIVE | FINAL; + +} diff --git a/java/jscip/ScipPropTiming.java b/java/jscip/ScipPropTiming.java new file mode 100644 index 0000000..f16b64d --- /dev/null +++ b/java/jscip/ScipPropTiming.java @@ -0,0 +1,11 @@ +package jscip; + +public class ScipPropTiming { + + public static final int BEFORELP = 0x001; + public static final int DURINGLPLOOP = 0x002; + public static final int AFTERLPLOOP = 0x004; + public static final int AFTERLPNODE = 0x008; + public static final int ALWAYS = BEFORELP | DURINGLPLOOP | AFTERLPLOOP | AFTERLPNODE; + +} diff --git a/src/scipjni.i b/src/scipjni.i index 4977496..109a6e6 100644 --- a/src/scipjni.i +++ b/src/scipjni.i @@ -8,6 +8,8 @@ #include "scip/scip.h" #include "scip/scipdefplugins.h" #include "objscip/objmessagehdlr.h" + #include "objscip/objeventhdlr.h" + #include "objscip/objconshdlr.h" /* if libscip is a shared library, ensure we use function calls instead of macros, for better binary compatibility across SCIP versions */ @@ -542,6 +544,85 @@ return messagehdlr; } + + /* BEGIN assist functions for accessing SCIP_Event data union members */ + SCIP_EventVarAdded getEventDataVarAdde(SCIP_Event event) { + return event.data.eventvaradded; + } + + SCIP_EventVarDeleted getEventDataVarDeleted(SCIP_Event event) { + return event.data.eventvardeleted; + } + + SCIP_EventVarFixed getEventDataVarFixed(SCIP_Event event) { + return event.data.eventvarfixed; + } + + SCIP_EventVarUnlocked getEventDataVarUnlocked(SCIP_Event event) { + return event.data.eventvarunlocked; + } + + SCIP_EventObjChg getEventDataObjChg(SCIP_Event event) { + return event.data.eventobjchg; + } + + SCIP_EventBdChg getEventDataBdChg(SCIP_Event event) { + return event.data.eventbdchg; + } + + SCIP_EventHole getEventDataHole(SCIP_Event event) { + return event.data.eventhole; + } + + SCIP_EventImplAdd getEventDataImplAdd(SCIP_Event event) { + return event.data.eventimpladd; + } + + SCIP_EventTypeChg getEventDataTypeChg(SCIP_Event event) { + return event.data.eventtypechg; + } + + SCIP_EventRowAddedSepa getEventDataRowAddedSepa(SCIP_Event event) { + return event.data.eventrowaddedsepa; + } + + SCIP_EventRowDeletedSepa getEventDataRowDeletedSepa(SCIP_Event event) { + return event.data.eventrowdeletedsepa; + } + + SCIP_EventRowAddedLP getEventDataRowAddedLp(SCIP_Event event) { + return event.data.eventrowaddedlp; + } + + SCIP_EventRowDeletedLP getEventDataRowDeletedLp(SCIP_Event event) { + return event.data.eventrowdeletedlp; + } + + SCIP_EventRowCoefChanged getEventDataRowCoefChanged(SCIP_Event event) { + return event.data.eventrowcoefchanged; + } + + SCIP_EventRowConstChanged getEventDataRowConstChanged(SCIP_Event event) { + return event.data.eventrowconstchanged; + } + + SCIP_EventRowSideChanged getEventDataRowSideChanged(SCIP_Event event) { + return event.data.eventrowsidechanged; + } + + SCIP_SOL* getEventDataSolution(SCIP_Event event) { + return event.data.sol; + } + + SCIP_NODE* getEventDataNode(SCIP_Event event) { + return event.data.node; + } + /* END assist functions for accessing SCIP_Event data union members*/ + + /* assist function to set result from constraint handler */ + void setResult(SCIP_Result* resultPtr, SCIP_Result scipResult) { + *resultPtr = scipResult; + } %} /* use SWIG internal arrays */ @@ -888,3 +969,522 @@ SCIP_CONS* createConsBasicVarbound(SCIP* scip, const char* name, SCIP_VAR* v SCIP_CONS* createConsBasicXor(SCIP* scip, const char* name, SCIP_Bool rhs, int nvars, SCIP_VAR** vars); void releaseCons(SCIP* scip, SCIP_CONS* cons); SCIP_MESSAGEHDLR* createObjMessagehdlr(scip::ObjMessagehdlr* objmessagehdlr, SCIP_Bool deleteobject); + +// from struct_event.h +struct SCIP_EventVarAdded +{ + SCIP_VAR* var; +}; + +struct SCIP_EventVarDeleted +{ + SCIP_VAR* var; +}; + +struct SCIP_EventVarFixed +{ + SCIP_VAR* var; +}; + +struct SCIP_EventVarUnlocked +{ + SCIP_VAR* var; +}; + +struct SCIP_EventObjChg +{ + SCIP_Real oldobj; + SCIP_Real newobj; + SCIP_VAR* var; +}; + +struct SCIP_EventBdChg +{ + SCIP_Real oldbound; + SCIP_Real newbound; + SCIP_VAR* var; +}; + +struct SCIP_EventHole +{ + SCIP_Real left; + SCIP_Real right; + SCIP_VAR* var; +}; + +struct SCIP_EventImplAdd +{ + SCIP_VAR* var; +}; + +struct SCIP_EventTypeChg +{ + SCIP_VARTYPE oldtype; + SCIP_VARTYPE newtype; + SCIP_VAR* var; +}; + +struct SCIP_EventRowAddedSepa +{ + SCIP_ROW* row; +}; + +struct SCIP_EventRowDeletedSepa +{ + SCIP_ROW* row; +}; + +struct SCIP_EventRowAddedLP +{ + SCIP_ROW* row; +}; + +struct SCIP_EventRowDeletedLP +{ + SCIP_ROW* row; +}; + +struct SCIP_EventRowCoefChanged +{ + SCIP_ROW* row; + SCIP_COL* col; + SCIP_Real oldval; + SCIP_Real newval; +}; + +struct SCIP_EventRowConstChanged +{ + SCIP_ROW* row; + SCIP_Real oldval; + SCIP_Real newval; +}; + +struct SCIP_EventRowSideChanged +{ + SCIP_ROW* row; + SCIP_SIDETYPE side; + SCIP_Real oldval; + SCIP_Real newval; +}; + +struct SCIP_Event +{ + union + { + SCIP_EventVarAdded eventvaradded; + SCIP_EventVarDeleted eventvardeleted; + SCIP_EventVarFixed eventvarfixed; + SCIP_EventVarUnlocked eventvarunlocked; + SCIP_EventObjChg eventobjchg; + SCIP_EventBdChg eventbdchg; + SCIP_EventHole eventhole; + SCIP_EventImplAdd eventimpladd; + SCIP_EventTypeChg eventtypechg; + SCIP_EventRowAddedSepa eventrowaddedsepa; + SCIP_EventRowDeletedSepa eventrowdeletedsepa; + SCIP_EventRowAddedLP eventrowaddedlp; + SCIP_EventRowDeletedLP eventrowdeletedlp; + SCIP_EventRowCoefChanged eventrowcoefchanged; + SCIP_EventRowConstChanged eventrowconstchanged; + SCIP_EventRowSideChanged eventrowsidechanged; + SCIP_NODE* node; + SCIP_SOL* sol; + } data; + SCIP_EVENTTYPE eventtype; +}; + +SCIP_EventVarAdded getEventDataVarAdde(SCIP_Event event); +SCIP_EventVarDeleted getEventDataVarDeleted(SCIP_Event event); +SCIP_EventVarFixed getEventDataVarFixed(SCIP_Event event); +SCIP_EventVarUnlocked getEventDataVarUnlocked(SCIP_Event event); +SCIP_EventObjChg getEventDataObjChg(SCIP_Event event); +SCIP_EventBdChg getEventDataBdChg(SCIP_Event event); +SCIP_EventHole getEventDataHole(SCIP_Event event); +SCIP_EventImplAdd getEventDataImplAdd(SCIP_Event event); +SCIP_EventTypeChg getEventDataTypeChg(SCIP_Event event); +SCIP_EventRowAddedSepa getEventDataRowAddedSepa(SCIP_Event event); +SCIP_EventRowDeletedSepa getEventDataRowDeletedSepa(SCIP_Event event); +SCIP_EventRowAddedLP getEventDataRowAddedLp(SCIP_Event event); +SCIP_EventRowDeletedLP getEventDataRowDeletedLp(SCIP_Event event); +SCIP_EventRowCoefChanged getEventDataRowCoefChanged(SCIP_Event event); +SCIP_EventRowConstChanged getEventDataRowConstChanged(SCIP_Event event); +SCIP_EventRowSideChanged getEventDataRowSideChanged(SCIP_Event event); +SCIP_SOL* getEventDataSolution(SCIP_Event event); +SCIP_NODE* getEventDataNode(SCIP_Event event); + +// from objeventhdlr.h +namespace scip { +class ObjEventhdlr { +public: + SCIP* scip_; + char* scip_name_; + char* scip_desc_; + + ObjEventhdlr(SCIP* scip, const char* name, const char* desc); + virtual ~ObjEventhdlr(); + virtual SCIP_RETCODE scip_free(SCIP* scip, SCIP_EVENTHDLR* eventhdlr); + virtual SCIP_RETCODE scip_init(SCIP* scip, SCIP_EVENTHDLR* eventhdlr); + virtual SCIP_RETCODE scip_exit(SCIP* scip, SCIP_EVENTHDLR* eventhdlr); + virtual SCIP_RETCODE scip_initsol(SCIP* scip, SCIP_EVENTHDLR* eventhdlr); + virtual SCIP_RETCODE scip_exitsol(SCIP* scip, SCIP_EVENTHDLR* eventhdlr); + virtual SCIP_RETCODE scip_delete(SCIP* scip, SCIP_EVENTHDLR* eventhdlr, SCIP_EVENTDATA** eventdata); + virtual SCIP_RETCODE scip_exec(SCIP* scip, SCIP_EVENTHDLR* eventhdlr, SCIP_Event* event, SCIP_EVENTDATA* eventdata); +}; +} /* namespace scip */ + +SCIP_RETCODE SCIPincludeObjEventhdlr(SCIP* scip, scip::ObjEventhdlr* objeventhdlr, SCIP_Bool deleteobject); +scip::ObjEventhdlr* SCIPfindObjEventhdlr(SCIP* scip, const char* name); +typedef long long int SCIP_EVENTTYPE; +SCIP_RETCODE SCIPcatchEvent( + SCIP* scip, + SCIP_EVENTTYPE eventtype, + SCIP_EVENTHDLR* eventhdlr, + SCIP_EVENTDATA* eventdata, + int* filterpos +); + +// from type_result.h +/** result codes for SCIP callback methods */ +enum SCIP_Result +{ + SCIP_DIDNOTRUN = 1, + SCIP_DELAYED = 2, + SCIP_DIDNOTFIND = 3, + SCIP_FEASIBLE = 4, + SCIP_INFEASIBLE = 5, + SCIP_UNBOUNDED = 6, + SCIP_CUTOFF = 7, + SCIP_SEPARATED = 8, + SCIP_NEWROUND = 9, + SCIP_REDUCEDDOM = 10, + SCIP_CONSADDED = 11, + SCIP_CONSCHANGED = 12, + SCIP_BRANCHED = 13, + SCIP_SOLVELP = 14, + SCIP_FOUNDSOL = 15, + SCIP_SUSPENDED = 16, + SCIP_SUCCESS = 17, + SCIP_DELAYNODE = 18 +}; + +// from type_var.h +enum SCIP_LockType +{ + SCIP_LOCKTYPE_MODEL = 0, + SCIP_LOCKTYPE_CONFLICT = 1 +}; + +// from objconshdlr.h +namespace scip { +class ObjConshdlr { +public: + /*lint --e{1540}*/ + + /** SCIP data structure */ + SCIP* scip_; + + /** name of the constraint handler */ + char* scip_name_; + + /** description of the constraint handler */ + char* scip_desc_; + + /** default separation priority of the constraint handler */ + const int scip_sepapriority_; + + /** default enforcing priority of the constraint handler */ + const int scip_enfopriority_; + + /** default checking priority of the constraint handler */ + const int scip_checkpriority_; + + /** default separation frequency of the constraint handler */ + const int scip_sepafreq_; + + /** default propagation frequency of the constraint handler */ + const int scip_propfreq_; + + /** default frequency of the constraint handler for eager evaluations in separation, propagation and enforcement */ + const int scip_eagerfreq_; + + /** maximal number of presolving rounds the constraint handler participates in (-1: no limit) */ + const int scip_maxprerounds_; + + /** should separation method be delayed, if other separators found cuts? */ + const SCIP_Bool scip_delaysepa_; + + /** should propagation method be delayed, if other propagators found reductions? */ + const SCIP_Bool scip_delayprop_; + + /** should the constraint handler be skipped, if no constraints are available? */ + const SCIP_Bool scip_needscons_; + + /** positions in the node solving loop where propagation method of constraint handler should be executed */ + const unsigned int scip_proptiming_; + + /**< timing mask of the constraint handler's presolving method */ + const unsigned int scip_presoltiming_; + + ObjConshdlr( + SCIP* scip, + const char* name, + const char* desc, + int sepapriority, + int enfopriority, + int checkpriority, + int sepafreq, + int propfreq, + int eagerfreq, + int scip_maxprerounds, + SCIP_Bool delaysepa, + SCIP_Bool delayprop, + SCIP_Bool needscons, + unsigned int proptiming, + unsigned int presoltiming + ); + + /** destructor */ + virtual ~ObjConshdlr(); + + virtual SCIP_RETCODE scip_free(SCIP* scip, SCIP_CONSHDLR* conshdlr); + virtual SCIP_RETCODE scip_init(SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss); + virtual SCIP_RETCODE scip_exit(SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss); + virtual SCIP_RETCODE scip_initpre(SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss); + virtual SCIP_RETCODE scip_exitpre(SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss); + virtual SCIP_RETCODE scip_initsol(SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss); + virtual SCIP_RETCODE scip_exitsol( + SCIP* scip, + SCIP_CONSHDLR* conshdlr, + SCIP_CONS** conss, + int nconss, + unsigned int restart + ); + virtual SCIP_RETCODE scip_delete( + SCIP* scip, + SCIP_CONSHDLR* conshdlr, + SCIP_CONS* cons, + SCIP_CONSDATA** consdata + ); + virtual SCIP_RETCODE scip_trans( + SCIP* scip, + SCIP_CONSHDLR* conshdlr, + SCIP_CONS* sourcecons, + SCIP_CONS** targetcons + ); + virtual SCIP_RETCODE scip_initlp( + SCIP* scip, + SCIP_CONSHDLR* conshdlr, + SCIP_CONS** conss, + int nconss, + unsigned int* infeasible + ); + virtual SCIP_RETCODE scip_sepalp( + SCIP* scip, + SCIP_CONSHDLR* conshdlr, + SCIP_CONS** conss, + int nconss, + int nusefulconss, + SCIP_Result* result + ); + virtual SCIP_RETCODE scip_sepasol( + SCIP* scip, + SCIP_CONSHDLR* conshdlr, + SCIP_CONS** conss, + int nconss, + int nusefulconss, + SCIP_SOL* sol, + SCIP_Result* result + ); + virtual SCIP_RETCODE scip_enfolp( + SCIP* scip, + SCIP_CONSHDLR* conshdlr, + SCIP_CONS** conss, + int nconss, + int nusefulconss, + unsigned int solinfeasible, + SCIP_Result* result + ); + virtual SCIP_RETCODE scip_enforelax( + SCIP* scip, + SCIP_SOL* sol, + SCIP_CONSHDLR* conshdlr, + SCIP_CONS** conss, + int nconss, + int nusefulconss, + unsigned int solinfeasible, + SCIP_Result* result + ); + virtual SCIP_RETCODE scip_enfops( + SCIP* scip, + SCIP_CONSHDLR* conshdlr, + SCIP_CONS** conss, + int nconss, + int nusefulconss, + unsigned int solinfeasible, + unsigned int objinfeasible, + SCIP_Result* result + ); + virtual SCIP_RETCODE scip_check( + SCIP* scip, + SCIP_CONSHDLR* conshdlr, + SCIP_CONS** conss, + int nconss, + SCIP_SOL* sol, + unsigned int checkintegrality, + unsigned int checklprows, + unsigned int printreason, + unsigned int completely, + SCIP_Result* result + ); + virtual SCIP_RETCODE scip_prop( + SCIP* scip, + SCIP_CONSHDLR* conshdlr, + SCIP_CONS** conss, + int nconss, + int nusefulconss, + int nmarkedconss, + SCIP_PROPTIMING proptiming, + SCIP_Result* result + ); + virtual SCIP_RETCODE scip_presol( + SCIP* scip, + SCIP_CONSHDLR* conshdlr, + SCIP_CONS** conss, + int nconss, + int nrounds, + SCIP_PRESOLTIMING presoltiming, + int nnewfixedvars, + int nnewaggrvars, + int nnewchgvartypes, + int nnewchgbds, + int nnewholes, + int nnewdelconss, + int nnewaddconss, + int nnewupgdconss, + int nnewchgcoefs, + int nnewchgsides, + int* nfixedvars, + int* naggrvars, + int* nchgvartypes, + int* nchgbds, + int* naddholes, + int* ndelconss, + int* naddconss, + int* nupgdconss, + int* nchgcoefs, + int* nchgsides, + SCIP_Result* result + ); + virtual SCIP_RETCODE scip_resprop( + SCIP* scip, + SCIP_CONSHDLR* conshdlr, + SCIP_CONS* cons, + SCIP_VAR* infervar, + int inferinfo, + SCIP_BOUNDTYPE boundtype, + SCIP_BDCHGIDX* bdchgidx, + double relaxedbd, + SCIP_Result* result + ); + virtual SCIP_RETCODE scip_lock( + SCIP* scip, + SCIP_CONSHDLR* conshdlr, + SCIP_CONS* cons, + SCIP_LockType locktype, + int nlockspos, + int nlocksneg + ); + virtual SCIP_RETCODE scip_active(SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons); + virtual SCIP_RETCODE scip_deactive(SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons); + virtual SCIP_RETCODE scip_enable(SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons); + virtual SCIP_RETCODE scip_disable(SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons); + virtual SCIP_RETCODE scip_delvars(SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss); + virtual SCIP_RETCODE scip_print(SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, FILE* file); + virtual SCIP_RETCODE scip_copy( + SCIP* scip, + SCIP_CONS** cons, + const char* name, + SCIP* sourcescip, + SCIP_CONSHDLR* sourceconshdlr, + SCIP_CONS* sourcecons, + SCIP_HASHMAP* varmap, + SCIP_HASHMAP* consmap, + unsigned int initial, + unsigned int separate, + unsigned int enforce, + unsigned int check, + unsigned int propagate, + unsigned int local, + unsigned int modifiable, + unsigned int dynamic, + unsigned int removable, + unsigned int stickingatnode, + unsigned int global, + unsigned int* valid + ); + virtual SCIP_RETCODE scip_parse( + SCIP* scip, + SCIP_CONSHDLR* conshdlr, + SCIP_CONS** cons, + const char* name, + const char* str, + unsigned int initial, + unsigned int separate, + unsigned int enforce, + unsigned int check, + unsigned int propagate, + unsigned int local, + unsigned int modifiable, + unsigned int dynamic, + unsigned int removable, + unsigned int stickingatnode, + unsigned int* success + ); + virtual SCIP_RETCODE scip_getvars( + SCIP* scip, + SCIP_CONSHDLR* conshdlr, + SCIP_CONS* cons, + SCIP_VAR** vars, + int varssize, + unsigned int* success + ); + virtual SCIP_RETCODE scip_getnvars( + SCIP* scip, + SCIP_CONSHDLR* conshdlr, + SCIP_CONS* cons, + int* nvars, + unsigned int* success + ); + virtual SCIP_RETCODE scip_getdivebdchgs( + SCIP* scip, + SCIP_CONSHDLR* conshdlr, + SCIP_DIVESET* diveset, + SCIP_SOL* sol, + unsigned int* success, + unsigned int* infeasible + ); + virtual SCIP_RETCODE scip_getpermsymgraph( + SCIP* scip, + SCIP_CONSHDLR* conshdlr, + SCIP_CONS* cons, + SYM_GRAPH* graph, + unsigned int* success + ); + virtual SCIP_RETCODE scip_getsignedpermsymgraph( + SCIP* scip, + SCIP_CONSHDLR* conshdlr, + SCIP_CONS* cons, + SYM_GRAPH* graph, + unsigned int* success + ); +}; + +} /* namespace scip */ + +SCIP_RETCODE SCIPincludeObjConshdlr(SCIP* scip, scip::ObjConshdlr* objconshdlr, SCIP_Bool deleteobject); +scip::ObjConshdlr* SCIPfindObjConshdlr(SCIP* scip, const char* name); +scip::ObjConshdlr* SCIPgetObjConshdlr(SCIP* scip, SCIP_CONSHDLR* conshdlr); +SCIP_RETCODE SCIPaddVarLocksType(SCIP* scip, SCIP_VAR* var, SCIP_LockType locktype, int nlocksdown, int nlocksup); +SCIP_RETCODE SCIPaddConsLocksType(SCIP* scip, SCIP_CONS* cons, SCIP_LockType locktype, int nlockspos, int nlocksneg); + +void setResult(SCIP_Result* resultPtr, SCIP_Result scipResult); diff --git a/src/scipjni_wrap.cxx b/src/scipjni_wrap.cxx index b06feb5..dc26e35 100644 --- a/src/scipjni_wrap.cxx +++ b/src/scipjni_wrap.cxx @@ -746,13 +746,15 @@ namespace Swig { namespace Swig { namespace { jclass jclass_SCIPJNIJNI = NULL; - jmethodID director_method_ids[5]; + jmethodID director_method_ids[45]; } } #include "scip/scip.h" #include "scip/scipdefplugins.h" #include "objscip/objmessagehdlr.h" + #include "objscip/objeventhdlr.h" + #include "objscip/objconshdlr.h" /* if libscip is a shared library, ensure we use function calls instead of macros, for better binary compatibility across SCIP versions */ @@ -1288,6 +1290,85 @@ namespace Swig { return messagehdlr; } + /* BEGIN assist functions for accessing SCIP_Event data union members */ + SCIP_EventVarAdded getEventDataVarAdde(SCIP_Event event) { + return event.data.eventvaradded; + } + + SCIP_EventVarDeleted getEventDataVarDeleted(SCIP_Event event) { + return event.data.eventvardeleted; + } + + SCIP_EventVarFixed getEventDataVarFixed(SCIP_Event event) { + return event.data.eventvarfixed; + } + + SCIP_EventVarUnlocked getEventDataVarUnlocked(SCIP_Event event) { + return event.data.eventvarunlocked; + } + + SCIP_EventObjChg getEventDataObjChg(SCIP_Event event) { + return event.data.eventobjchg; + } + + SCIP_EventBdChg getEventDataBdChg(SCIP_Event event) { + return event.data.eventbdchg; + } + + SCIP_EventHole getEventDataHole(SCIP_Event event) { + return event.data.eventhole; + } + + SCIP_EventImplAdd getEventDataImplAdd(SCIP_Event event) { + return event.data.eventimpladd; + } + + SCIP_EventTypeChg getEventDataTypeChg(SCIP_Event event) { + return event.data.eventtypechg; + } + + SCIP_EventRowAddedSepa getEventDataRowAddedSepa(SCIP_Event event) { + return event.data.eventrowaddedsepa; + } + + SCIP_EventRowDeletedSepa getEventDataRowDeletedSepa(SCIP_Event event) { + return event.data.eventrowdeletedsepa; + } + + SCIP_EventRowAddedLP getEventDataRowAddedLp(SCIP_Event event) { + return event.data.eventrowaddedlp; + } + + SCIP_EventRowDeletedLP getEventDataRowDeletedLp(SCIP_Event event) { + return event.data.eventrowdeletedlp; + } + + SCIP_EventRowCoefChanged getEventDataRowCoefChanged(SCIP_Event event) { + return event.data.eventrowcoefchanged; + } + + SCIP_EventRowConstChanged getEventDataRowConstChanged(SCIP_Event event) { + return event.data.eventrowconstchanged; + } + + SCIP_EventRowSideChanged getEventDataRowSideChanged(SCIP_Event event) { + return event.data.eventrowsidechanged; + } + + SCIP_SOL* getEventDataSolution(SCIP_Event event) { + return event.data.sol; + } + + SCIP_NODE* getEventDataNode(SCIP_Event event) { + return event.data.node; + } + /* END assist functions for accessing SCIP_Event data union members*/ + + /* assist function to set result from constraint handler */ + void setResult(SCIP_Result* resultPtr, SCIP_Result scipResult) { + *resultPtr = scipResult; + } + static char *new_char_array(int nelements) { return new char[nelements](); @@ -1708,1918 +1789,7988 @@ void SwigDirector_ObjMessagehdlr::swig_connect_director(JNIEnv *jenv, jobject js } - -#ifdef __cplusplus -extern "C" { -#endif - -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_new_1char_1array(JNIEnv *jenv, jclass jcls, jint jarg1) { - jlong jresult = 0 ; - int arg1 ; - char *result = 0 ; - - (void)jenv; - (void)jcls; - arg1 = (int)jarg1; - result = (char *)new_char_array(arg1); - *(char **)&jresult = result; - return jresult; +SwigDirector_ObjEventhdlr::SwigDirector_ObjEventhdlr(JNIEnv *jenv, SCIP *scip, char const *name, char const *desc) : scip::ObjEventhdlr(scip, name, desc), Swig::Director(jenv) { } - -SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_delete_1char_1array(JNIEnv *jenv, jclass jcls, jlong jarg1) { - char *arg1 = (char *) 0 ; - - (void)jenv; - (void)jcls; - arg1 = *(char **)&jarg1; - delete_char_array(arg1); - +SwigDirector_ObjEventhdlr::~SwigDirector_ObjEventhdlr() { + swig_disconnect_director_self("swigDirectorDisconnect"); } -SWIGEXPORT jchar JNICALL Java_jscip_SCIPJNIJNI_char_1array_1getitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) { - jchar jresult = 0 ; - char *arg1 = (char *) 0 ; - int arg2 ; - char result; - - (void)jenv; - (void)jcls; - arg1 = *(char **)&jarg1; - arg2 = (int)jarg2; - result = (char)char_array_getitem(arg1,arg2); - jresult = (jchar)result; +SCIP_RETCODE SwigDirector_ObjEventhdlr::scip_free(SCIP *scip, SCIP_EVENTHDLR *eventhdlr) { + SCIP_RETCODE c_result = SwigValueInit< SCIP_RETCODE >() ; + jint jresult = 0 ; + JNIEnvWrapper swigjnienv(this) ; + JNIEnv * jenv = swigjnienv.getJNIEnv() ; + jobject swigjobj = (jobject) NULL ; + jlong jscip = 0 ; + jlong jeventhdlr = 0 ; - return jresult; + if (!swig_override[0]) { + return scip::ObjEventhdlr::scip_free(scip,eventhdlr); + } + swigjobj = swig_get_self(jenv); + if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { + *((SCIP **)&jscip) = (SCIP *) scip; + *((SCIP_EVENTHDLR **)&jeventhdlr) = (SCIP_EVENTHDLR *) eventhdlr; + jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SCIPJNIJNI, Swig::director_method_ids[5], swigjobj, jscip, jeventhdlr); + jthrowable swigerror = jenv->ExceptionOccurred(); + if (swigerror) { + Swig::DirectorException::raise(jenv, swigerror); + } + + c_result = (SCIP_RETCODE)jresult; + } else { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in scip::ObjEventhdlr::scip_free "); + } + if (swigjobj) jenv->DeleteLocalRef(swigjobj); + return c_result; } - -SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_char_1array_1setitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2, jchar jarg3) { - char *arg1 = (char *) 0 ; - int arg2 ; - char arg3 ; - - (void)jenv; - (void)jcls; - arg1 = *(char **)&jarg1; - arg2 = (int)jarg2; - arg3 = (char)jarg3; - char_array_setitem(arg1,arg2,arg3); +SCIP_RETCODE SwigDirector_ObjEventhdlr::scip_init(SCIP *scip, SCIP_EVENTHDLR *eventhdlr) { + SCIP_RETCODE c_result = SwigValueInit< SCIP_RETCODE >() ; + jint jresult = 0 ; + JNIEnvWrapper swigjnienv(this) ; + JNIEnv * jenv = swigjnienv.getJNIEnv() ; + jobject swigjobj = (jobject) NULL ; + jlong jscip = 0 ; + jlong jeventhdlr = 0 ; + if (!swig_override[1]) { + return scip::ObjEventhdlr::scip_init(scip,eventhdlr); + } + swigjobj = swig_get_self(jenv); + if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { + *((SCIP **)&jscip) = (SCIP *) scip; + *((SCIP_EVENTHDLR **)&jeventhdlr) = (SCIP_EVENTHDLR *) eventhdlr; + jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SCIPJNIJNI, Swig::director_method_ids[6], swigjobj, jscip, jeventhdlr); + jthrowable swigerror = jenv->ExceptionOccurred(); + if (swigerror) { + Swig::DirectorException::raise(jenv, swigerror); + } + + c_result = (SCIP_RETCODE)jresult; + } else { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in scip::ObjEventhdlr::scip_init "); + } + if (swigjobj) jenv->DeleteLocalRef(swigjobj); + return c_result; } - -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_new_1double_1array(JNIEnv *jenv, jclass jcls, jint jarg1) { - jlong jresult = 0 ; - int arg1 ; - double *result = 0 ; +SCIP_RETCODE SwigDirector_ObjEventhdlr::scip_exit(SCIP *scip, SCIP_EVENTHDLR *eventhdlr) { + SCIP_RETCODE c_result = SwigValueInit< SCIP_RETCODE >() ; + jint jresult = 0 ; + JNIEnvWrapper swigjnienv(this) ; + JNIEnv * jenv = swigjnienv.getJNIEnv() ; + jobject swigjobj = (jobject) NULL ; + jlong jscip = 0 ; + jlong jeventhdlr = 0 ; - (void)jenv; - (void)jcls; - arg1 = (int)jarg1; - result = (double *)new_double_array(arg1); - *(double **)&jresult = result; - return jresult; + if (!swig_override[2]) { + return scip::ObjEventhdlr::scip_exit(scip,eventhdlr); + } + swigjobj = swig_get_self(jenv); + if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { + *((SCIP **)&jscip) = (SCIP *) scip; + *((SCIP_EVENTHDLR **)&jeventhdlr) = (SCIP_EVENTHDLR *) eventhdlr; + jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SCIPJNIJNI, Swig::director_method_ids[7], swigjobj, jscip, jeventhdlr); + jthrowable swigerror = jenv->ExceptionOccurred(); + if (swigerror) { + Swig::DirectorException::raise(jenv, swigerror); + } + + c_result = (SCIP_RETCODE)jresult; + } else { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in scip::ObjEventhdlr::scip_exit "); + } + if (swigjobj) jenv->DeleteLocalRef(swigjobj); + return c_result; } - -SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_delete_1double_1array(JNIEnv *jenv, jclass jcls, jlong jarg1) { - double *arg1 = (double *) 0 ; +SCIP_RETCODE SwigDirector_ObjEventhdlr::scip_initsol(SCIP *scip, SCIP_EVENTHDLR *eventhdlr) { + SCIP_RETCODE c_result = SwigValueInit< SCIP_RETCODE >() ; + jint jresult = 0 ; + JNIEnvWrapper swigjnienv(this) ; + JNIEnv * jenv = swigjnienv.getJNIEnv() ; + jobject swigjobj = (jobject) NULL ; + jlong jscip = 0 ; + jlong jeventhdlr = 0 ; - (void)jenv; - (void)jcls; - arg1 = *(double **)&jarg1; - delete_double_array(arg1); + if (!swig_override[3]) { + return scip::ObjEventhdlr::scip_initsol(scip,eventhdlr); + } + swigjobj = swig_get_self(jenv); + if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { + *((SCIP **)&jscip) = (SCIP *) scip; + *((SCIP_EVENTHDLR **)&jeventhdlr) = (SCIP_EVENTHDLR *) eventhdlr; + jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SCIPJNIJNI, Swig::director_method_ids[8], swigjobj, jscip, jeventhdlr); + jthrowable swigerror = jenv->ExceptionOccurred(); + if (swigerror) { + Swig::DirectorException::raise(jenv, swigerror); + } + + c_result = (SCIP_RETCODE)jresult; + } else { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in scip::ObjEventhdlr::scip_initsol "); + } + if (swigjobj) jenv->DeleteLocalRef(swigjobj); + return c_result; } - -SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_double_1array_1getitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) { - jdouble jresult = 0 ; - double *arg1 = (double *) 0 ; - int arg2 ; - double result; +SCIP_RETCODE SwigDirector_ObjEventhdlr::scip_exitsol(SCIP *scip, SCIP_EVENTHDLR *eventhdlr) { + SCIP_RETCODE c_result = SwigValueInit< SCIP_RETCODE >() ; + jint jresult = 0 ; + JNIEnvWrapper swigjnienv(this) ; + JNIEnv * jenv = swigjnienv.getJNIEnv() ; + jobject swigjobj = (jobject) NULL ; + jlong jscip = 0 ; + jlong jeventhdlr = 0 ; - (void)jenv; - (void)jcls; - arg1 = *(double **)&jarg1; - arg2 = (int)jarg2; - result = (double)double_array_getitem(arg1,arg2); - jresult = (jdouble)result; - return jresult; + if (!swig_override[4]) { + return scip::ObjEventhdlr::scip_exitsol(scip,eventhdlr); + } + swigjobj = swig_get_self(jenv); + if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { + *((SCIP **)&jscip) = (SCIP *) scip; + *((SCIP_EVENTHDLR **)&jeventhdlr) = (SCIP_EVENTHDLR *) eventhdlr; + jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SCIPJNIJNI, Swig::director_method_ids[9], swigjobj, jscip, jeventhdlr); + jthrowable swigerror = jenv->ExceptionOccurred(); + if (swigerror) { + Swig::DirectorException::raise(jenv, swigerror); + } + + c_result = (SCIP_RETCODE)jresult; + } else { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in scip::ObjEventhdlr::scip_exitsol "); + } + if (swigjobj) jenv->DeleteLocalRef(swigjobj); + return c_result; } - -SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_double_1array_1setitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2, jdouble jarg3) { - double *arg1 = (double *) 0 ; - int arg2 ; - double arg3 ; +SCIP_RETCODE SwigDirector_ObjEventhdlr::scip_delete(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA **eventdata) { + SCIP_RETCODE c_result = SwigValueInit< SCIP_RETCODE >() ; + jint jresult = 0 ; + JNIEnvWrapper swigjnienv(this) ; + JNIEnv * jenv = swigjnienv.getJNIEnv() ; + jobject swigjobj = (jobject) NULL ; + jlong jscip = 0 ; + jlong jeventhdlr = 0 ; + jlong jeventdata = 0 ; - (void)jenv; - (void)jcls; - arg1 = *(double **)&jarg1; - arg2 = (int)jarg2; - arg3 = (double)jarg3; - double_array_setitem(arg1,arg2,arg3); + if (!swig_override[5]) { + return scip::ObjEventhdlr::scip_delete(scip,eventhdlr,eventdata); + } + swigjobj = swig_get_self(jenv); + if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { + *((SCIP **)&jscip) = (SCIP *) scip; + *((SCIP_EVENTHDLR **)&jeventhdlr) = (SCIP_EVENTHDLR *) eventhdlr; + *((SCIP_EVENTDATA ***)&jeventdata) = (SCIP_EVENTDATA **) eventdata; + jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SCIPJNIJNI, Swig::director_method_ids[10], swigjobj, jscip, jeventhdlr, jeventdata); + jthrowable swigerror = jenv->ExceptionOccurred(); + if (swigerror) { + Swig::DirectorException::raise(jenv, swigerror); + } + + c_result = (SCIP_RETCODE)jresult; + } else { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in scip::ObjEventhdlr::scip_delete "); + } + if (swigjobj) jenv->DeleteLocalRef(swigjobj); + return c_result; } - -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_new_1int_1array(JNIEnv *jenv, jclass jcls, jint jarg1) { - jlong jresult = 0 ; - int arg1 ; - int *result = 0 ; +SCIP_RETCODE SwigDirector_ObjEventhdlr::scip_exec(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_Event *event, SCIP_EVENTDATA *eventdata) { + SCIP_RETCODE c_result = SwigValueInit< SCIP_RETCODE >() ; + jint jresult = 0 ; + JNIEnvWrapper swigjnienv(this) ; + JNIEnv * jenv = swigjnienv.getJNIEnv() ; + jobject swigjobj = (jobject) NULL ; + jlong jscip = 0 ; + jlong jeventhdlr = 0 ; + jlong jevent = 0 ; + jlong jeventdata = 0 ; - (void)jenv; - (void)jcls; + if (!swig_override[6]) { + return scip::ObjEventhdlr::scip_exec(scip,eventhdlr,event,eventdata); + } + swigjobj = swig_get_self(jenv); + if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { + *((SCIP **)&jscip) = (SCIP *) scip; + *((SCIP_EVENTHDLR **)&jeventhdlr) = (SCIP_EVENTHDLR *) eventhdlr; + *((SCIP_Event **)&jevent) = (SCIP_Event *) event; + *((SCIP_EVENTDATA **)&jeventdata) = (SCIP_EVENTDATA *) eventdata; + jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SCIPJNIJNI, Swig::director_method_ids[11], swigjobj, jscip, jeventhdlr, jevent, jeventdata); + jthrowable swigerror = jenv->ExceptionOccurred(); + if (swigerror) { + Swig::DirectorException::raise(jenv, swigerror); + } + + c_result = (SCIP_RETCODE)jresult; + } else { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in scip::ObjEventhdlr::scip_exec "); + } + if (swigjobj) jenv->DeleteLocalRef(swigjobj); + return c_result; +} + +void SwigDirector_ObjEventhdlr::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) { + static struct { + const char *mname; + const char *mdesc; + jmethodID base_methid; + } methods[] = { + { + "scip_free", "(Ljscip/SWIGTYPE_p_SCIP;Ljscip/SWIGTYPE_p_SCIP_EVENTHDLR;)Ljscip/SCIP_Retcode;", NULL + }, + { + "scip_init", "(Ljscip/SWIGTYPE_p_SCIP;Ljscip/SWIGTYPE_p_SCIP_EVENTHDLR;)Ljscip/SCIP_Retcode;", NULL + }, + { + "scip_exit", "(Ljscip/SWIGTYPE_p_SCIP;Ljscip/SWIGTYPE_p_SCIP_EVENTHDLR;)Ljscip/SCIP_Retcode;", NULL + }, + { + "scip_initsol", "(Ljscip/SWIGTYPE_p_SCIP;Ljscip/SWIGTYPE_p_SCIP_EVENTHDLR;)Ljscip/SCIP_Retcode;", NULL + }, + { + "scip_exitsol", "(Ljscip/SWIGTYPE_p_SCIP;Ljscip/SWIGTYPE_p_SCIP_EVENTHDLR;)Ljscip/SCIP_Retcode;", NULL + }, + { + "scip_delete", "(Ljscip/SWIGTYPE_p_SCIP;Ljscip/SWIGTYPE_p_SCIP_EVENTHDLR;Ljscip/SWIGTYPE_p_p_SCIP_EVENTDATA;)Ljscip/SCIP_Retcode;", NULL + }, + { + "scip_exec", "(Ljscip/SWIGTYPE_p_SCIP;Ljscip/SWIGTYPE_p_SCIP_EVENTHDLR;Ljscip/SCIP_Event;Ljscip/SWIGTYPE_p_SCIP_EVENTDATA;)Ljscip/SCIP_Retcode;", NULL + } + }; + + static jclass baseclass = 0 ; + + if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) { + if (!baseclass) { + baseclass = jenv->FindClass("jscip/ObjEventhdlr"); + if (!baseclass) return; + baseclass = (jclass) jenv->NewGlobalRef(baseclass); + } + bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true); + for (int i = 0; i < 7; ++i) { + if (!methods[i].base_methid) { + methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc); + if (!methods[i].base_methid) return; + } + swig_override[i] = false; + if (derived) { + jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc); + swig_override[i] = (methid != methods[i].base_methid); + jenv->ExceptionClear(); + } + } + } +} + + +SwigDirector_ObjConshdlr::SwigDirector_ObjConshdlr(JNIEnv *jenv, SCIP *scip, char const *name, char const *desc, int sepapriority, int enfopriority, int checkpriority, int sepafreq, int propfreq, int eagerfreq, int scip_maxprerounds, unsigned int delaysepa, unsigned int delayprop, unsigned int needscons, unsigned int proptiming, unsigned int presoltiming) : scip::ObjConshdlr(scip, name, desc, sepapriority, enfopriority, checkpriority, sepafreq, propfreq, eagerfreq, scip_maxprerounds, delaysepa, delayprop, needscons, proptiming, presoltiming), Swig::Director(jenv) { +} + +SwigDirector_ObjConshdlr::~SwigDirector_ObjConshdlr() { + swig_disconnect_director_self("swigDirectorDisconnect"); +} + + +SCIP_RETCODE SwigDirector_ObjConshdlr::scip_free(SCIP *scip, SCIP_CONSHDLR *conshdlr) { + SCIP_RETCODE c_result = SwigValueInit< SCIP_RETCODE >() ; + jint jresult = 0 ; + JNIEnvWrapper swigjnienv(this) ; + JNIEnv * jenv = swigjnienv.getJNIEnv() ; + jobject swigjobj = (jobject) NULL ; + jlong jscip = 0 ; + jlong jconshdlr = 0 ; + + if (!swig_override[0]) { + return scip::ObjConshdlr::scip_free(scip,conshdlr); + } + swigjobj = swig_get_self(jenv); + if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { + *((SCIP **)&jscip) = (SCIP *) scip; + *((SCIP_CONSHDLR **)&jconshdlr) = (SCIP_CONSHDLR *) conshdlr; + jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SCIPJNIJNI, Swig::director_method_ids[12], swigjobj, jscip, jconshdlr); + jthrowable swigerror = jenv->ExceptionOccurred(); + if (swigerror) { + Swig::DirectorException::raise(jenv, swigerror); + } + + c_result = (SCIP_RETCODE)jresult; + } else { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in scip::ObjConshdlr::scip_free "); + } + if (swigjobj) jenv->DeleteLocalRef(swigjobj); + return c_result; +} + +SCIP_RETCODE SwigDirector_ObjConshdlr::scip_init(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss) { + SCIP_RETCODE c_result = SwigValueInit< SCIP_RETCODE >() ; + jint jresult = 0 ; + JNIEnvWrapper swigjnienv(this) ; + JNIEnv * jenv = swigjnienv.getJNIEnv() ; + jobject swigjobj = (jobject) NULL ; + jlong jscip = 0 ; + jlong jconshdlr = 0 ; + jlong jconss = 0 ; + jint jnconss ; + + if (!swig_override[1]) { + return scip::ObjConshdlr::scip_init(scip,conshdlr,conss,nconss); + } + swigjobj = swig_get_self(jenv); + if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { + *((SCIP **)&jscip) = (SCIP *) scip; + *((SCIP_CONSHDLR **)&jconshdlr) = (SCIP_CONSHDLR *) conshdlr; + *((SCIP_CONS ***)&jconss) = (SCIP_CONS **) conss; + jnconss = (jint) nconss; + jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SCIPJNIJNI, Swig::director_method_ids[13], swigjobj, jscip, jconshdlr, jconss, jnconss); + jthrowable swigerror = jenv->ExceptionOccurred(); + if (swigerror) { + Swig::DirectorException::raise(jenv, swigerror); + } + + c_result = (SCIP_RETCODE)jresult; + } else { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in scip::ObjConshdlr::scip_init "); + } + if (swigjobj) jenv->DeleteLocalRef(swigjobj); + return c_result; +} + +SCIP_RETCODE SwigDirector_ObjConshdlr::scip_exit(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss) { + SCIP_RETCODE c_result = SwigValueInit< SCIP_RETCODE >() ; + jint jresult = 0 ; + JNIEnvWrapper swigjnienv(this) ; + JNIEnv * jenv = swigjnienv.getJNIEnv() ; + jobject swigjobj = (jobject) NULL ; + jlong jscip = 0 ; + jlong jconshdlr = 0 ; + jlong jconss = 0 ; + jint jnconss ; + + if (!swig_override[2]) { + return scip::ObjConshdlr::scip_exit(scip,conshdlr,conss,nconss); + } + swigjobj = swig_get_self(jenv); + if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { + *((SCIP **)&jscip) = (SCIP *) scip; + *((SCIP_CONSHDLR **)&jconshdlr) = (SCIP_CONSHDLR *) conshdlr; + *((SCIP_CONS ***)&jconss) = (SCIP_CONS **) conss; + jnconss = (jint) nconss; + jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SCIPJNIJNI, Swig::director_method_ids[14], swigjobj, jscip, jconshdlr, jconss, jnconss); + jthrowable swigerror = jenv->ExceptionOccurred(); + if (swigerror) { + Swig::DirectorException::raise(jenv, swigerror); + } + + c_result = (SCIP_RETCODE)jresult; + } else { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in scip::ObjConshdlr::scip_exit "); + } + if (swigjobj) jenv->DeleteLocalRef(swigjobj); + return c_result; +} + +SCIP_RETCODE SwigDirector_ObjConshdlr::scip_initpre(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss) { + SCIP_RETCODE c_result = SwigValueInit< SCIP_RETCODE >() ; + jint jresult = 0 ; + JNIEnvWrapper swigjnienv(this) ; + JNIEnv * jenv = swigjnienv.getJNIEnv() ; + jobject swigjobj = (jobject) NULL ; + jlong jscip = 0 ; + jlong jconshdlr = 0 ; + jlong jconss = 0 ; + jint jnconss ; + + if (!swig_override[3]) { + return scip::ObjConshdlr::scip_initpre(scip,conshdlr,conss,nconss); + } + swigjobj = swig_get_self(jenv); + if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { + *((SCIP **)&jscip) = (SCIP *) scip; + *((SCIP_CONSHDLR **)&jconshdlr) = (SCIP_CONSHDLR *) conshdlr; + *((SCIP_CONS ***)&jconss) = (SCIP_CONS **) conss; + jnconss = (jint) nconss; + jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SCIPJNIJNI, Swig::director_method_ids[15], swigjobj, jscip, jconshdlr, jconss, jnconss); + jthrowable swigerror = jenv->ExceptionOccurred(); + if (swigerror) { + Swig::DirectorException::raise(jenv, swigerror); + } + + c_result = (SCIP_RETCODE)jresult; + } else { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in scip::ObjConshdlr::scip_initpre "); + } + if (swigjobj) jenv->DeleteLocalRef(swigjobj); + return c_result; +} + +SCIP_RETCODE SwigDirector_ObjConshdlr::scip_exitpre(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss) { + SCIP_RETCODE c_result = SwigValueInit< SCIP_RETCODE >() ; + jint jresult = 0 ; + JNIEnvWrapper swigjnienv(this) ; + JNIEnv * jenv = swigjnienv.getJNIEnv() ; + jobject swigjobj = (jobject) NULL ; + jlong jscip = 0 ; + jlong jconshdlr = 0 ; + jlong jconss = 0 ; + jint jnconss ; + + if (!swig_override[4]) { + return scip::ObjConshdlr::scip_exitpre(scip,conshdlr,conss,nconss); + } + swigjobj = swig_get_self(jenv); + if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { + *((SCIP **)&jscip) = (SCIP *) scip; + *((SCIP_CONSHDLR **)&jconshdlr) = (SCIP_CONSHDLR *) conshdlr; + *((SCIP_CONS ***)&jconss) = (SCIP_CONS **) conss; + jnconss = (jint) nconss; + jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SCIPJNIJNI, Swig::director_method_ids[16], swigjobj, jscip, jconshdlr, jconss, jnconss); + jthrowable swigerror = jenv->ExceptionOccurred(); + if (swigerror) { + Swig::DirectorException::raise(jenv, swigerror); + } + + c_result = (SCIP_RETCODE)jresult; + } else { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in scip::ObjConshdlr::scip_exitpre "); + } + if (swigjobj) jenv->DeleteLocalRef(swigjobj); + return c_result; +} + +SCIP_RETCODE SwigDirector_ObjConshdlr::scip_initsol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss) { + SCIP_RETCODE c_result = SwigValueInit< SCIP_RETCODE >() ; + jint jresult = 0 ; + JNIEnvWrapper swigjnienv(this) ; + JNIEnv * jenv = swigjnienv.getJNIEnv() ; + jobject swigjobj = (jobject) NULL ; + jlong jscip = 0 ; + jlong jconshdlr = 0 ; + jlong jconss = 0 ; + jint jnconss ; + + if (!swig_override[5]) { + return scip::ObjConshdlr::scip_initsol(scip,conshdlr,conss,nconss); + } + swigjobj = swig_get_self(jenv); + if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { + *((SCIP **)&jscip) = (SCIP *) scip; + *((SCIP_CONSHDLR **)&jconshdlr) = (SCIP_CONSHDLR *) conshdlr; + *((SCIP_CONS ***)&jconss) = (SCIP_CONS **) conss; + jnconss = (jint) nconss; + jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SCIPJNIJNI, Swig::director_method_ids[17], swigjobj, jscip, jconshdlr, jconss, jnconss); + jthrowable swigerror = jenv->ExceptionOccurred(); + if (swigerror) { + Swig::DirectorException::raise(jenv, swigerror); + } + + c_result = (SCIP_RETCODE)jresult; + } else { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in scip::ObjConshdlr::scip_initsol "); + } + if (swigjobj) jenv->DeleteLocalRef(swigjobj); + return c_result; +} + +SCIP_RETCODE SwigDirector_ObjConshdlr::scip_exitsol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, unsigned int restart) { + SCIP_RETCODE c_result = SwigValueInit< SCIP_RETCODE >() ; + jint jresult = 0 ; + JNIEnvWrapper swigjnienv(this) ; + JNIEnv * jenv = swigjnienv.getJNIEnv() ; + jobject swigjobj = (jobject) NULL ; + jlong jscip = 0 ; + jlong jconshdlr = 0 ; + jlong jconss = 0 ; + jint jnconss ; + jlong jrestart ; + + if (!swig_override[6]) { + return scip::ObjConshdlr::scip_exitsol(scip,conshdlr,conss,nconss,restart); + } + swigjobj = swig_get_self(jenv); + if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { + *((SCIP **)&jscip) = (SCIP *) scip; + *((SCIP_CONSHDLR **)&jconshdlr) = (SCIP_CONSHDLR *) conshdlr; + *((SCIP_CONS ***)&jconss) = (SCIP_CONS **) conss; + jnconss = (jint) nconss; + jrestart = (jlong) restart; + jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SCIPJNIJNI, Swig::director_method_ids[18], swigjobj, jscip, jconshdlr, jconss, jnconss, jrestart); + jthrowable swigerror = jenv->ExceptionOccurred(); + if (swigerror) { + Swig::DirectorException::raise(jenv, swigerror); + } + + c_result = (SCIP_RETCODE)jresult; + } else { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in scip::ObjConshdlr::scip_exitsol "); + } + if (swigjobj) jenv->DeleteLocalRef(swigjobj); + return c_result; +} + +SCIP_RETCODE SwigDirector_ObjConshdlr::scip_delete(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons, SCIP_CONSDATA **consdata) { + SCIP_RETCODE c_result = SwigValueInit< SCIP_RETCODE >() ; + jint jresult = 0 ; + JNIEnvWrapper swigjnienv(this) ; + JNIEnv * jenv = swigjnienv.getJNIEnv() ; + jobject swigjobj = (jobject) NULL ; + jlong jscip = 0 ; + jlong jconshdlr = 0 ; + jlong jcons = 0 ; + jlong jconsdata = 0 ; + + if (!swig_override[7]) { + return scip::ObjConshdlr::scip_delete(scip,conshdlr,cons,consdata); + } + swigjobj = swig_get_self(jenv); + if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { + *((SCIP **)&jscip) = (SCIP *) scip; + *((SCIP_CONSHDLR **)&jconshdlr) = (SCIP_CONSHDLR *) conshdlr; + *((SCIP_CONS **)&jcons) = (SCIP_CONS *) cons; + *((SCIP_CONSDATA ***)&jconsdata) = (SCIP_CONSDATA **) consdata; + jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SCIPJNIJNI, Swig::director_method_ids[19], swigjobj, jscip, jconshdlr, jcons, jconsdata); + jthrowable swigerror = jenv->ExceptionOccurred(); + if (swigerror) { + Swig::DirectorException::raise(jenv, swigerror); + } + + c_result = (SCIP_RETCODE)jresult; + } else { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in scip::ObjConshdlr::scip_delete "); + } + if (swigjobj) jenv->DeleteLocalRef(swigjobj); + return c_result; +} + +SCIP_RETCODE SwigDirector_ObjConshdlr::scip_trans(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *sourcecons, SCIP_CONS **targetcons) { + SCIP_RETCODE c_result = SwigValueInit< SCIP_RETCODE >() ; + jint jresult = 0 ; + JNIEnvWrapper swigjnienv(this) ; + JNIEnv * jenv = swigjnienv.getJNIEnv() ; + jobject swigjobj = (jobject) NULL ; + jlong jscip = 0 ; + jlong jconshdlr = 0 ; + jlong jsourcecons = 0 ; + jlong jtargetcons = 0 ; + + if (!swig_override[8]) { + return scip::ObjConshdlr::scip_trans(scip,conshdlr,sourcecons,targetcons); + } + swigjobj = swig_get_self(jenv); + if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { + *((SCIP **)&jscip) = (SCIP *) scip; + *((SCIP_CONSHDLR **)&jconshdlr) = (SCIP_CONSHDLR *) conshdlr; + *((SCIP_CONS **)&jsourcecons) = (SCIP_CONS *) sourcecons; + *((SCIP_CONS ***)&jtargetcons) = (SCIP_CONS **) targetcons; + jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SCIPJNIJNI, Swig::director_method_ids[20], swigjobj, jscip, jconshdlr, jsourcecons, jtargetcons); + jthrowable swigerror = jenv->ExceptionOccurred(); + if (swigerror) { + Swig::DirectorException::raise(jenv, swigerror); + } + + c_result = (SCIP_RETCODE)jresult; + } else { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in scip::ObjConshdlr::scip_trans "); + } + if (swigjobj) jenv->DeleteLocalRef(swigjobj); + return c_result; +} + +SCIP_RETCODE SwigDirector_ObjConshdlr::scip_initlp(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, unsigned int *infeasible) { + SCIP_RETCODE c_result = SwigValueInit< SCIP_RETCODE >() ; + jint jresult = 0 ; + JNIEnvWrapper swigjnienv(this) ; + JNIEnv * jenv = swigjnienv.getJNIEnv() ; + jobject swigjobj = (jobject) NULL ; + jlong jscip = 0 ; + jlong jconshdlr = 0 ; + jlong jconss = 0 ; + jint jnconss ; + jlong jinfeasible = 0 ; + + if (!swig_override[9]) { + return scip::ObjConshdlr::scip_initlp(scip,conshdlr,conss,nconss,infeasible); + } + swigjobj = swig_get_self(jenv); + if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { + *((SCIP **)&jscip) = (SCIP *) scip; + *((SCIP_CONSHDLR **)&jconshdlr) = (SCIP_CONSHDLR *) conshdlr; + *((SCIP_CONS ***)&jconss) = (SCIP_CONS **) conss; + jnconss = (jint) nconss; + *((unsigned int **)&jinfeasible) = (unsigned int *) infeasible; + jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SCIPJNIJNI, Swig::director_method_ids[21], swigjobj, jscip, jconshdlr, jconss, jnconss, jinfeasible); + jthrowable swigerror = jenv->ExceptionOccurred(); + if (swigerror) { + Swig::DirectorException::raise(jenv, swigerror); + } + + c_result = (SCIP_RETCODE)jresult; + } else { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in scip::ObjConshdlr::scip_initlp "); + } + if (swigjobj) jenv->DeleteLocalRef(swigjobj); + return c_result; +} + +SCIP_RETCODE SwigDirector_ObjConshdlr::scip_sepalp(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, int nusefulconss, SCIP_Result *result) { + SCIP_RETCODE c_result = SwigValueInit< SCIP_RETCODE >() ; + jint jresult = 0 ; + JNIEnvWrapper swigjnienv(this) ; + JNIEnv * jenv = swigjnienv.getJNIEnv() ; + jobject swigjobj = (jobject) NULL ; + jlong jscip = 0 ; + jlong jconshdlr = 0 ; + jlong jconss = 0 ; + jint jnconss ; + jint jnusefulconss ; + + if (!swig_override[10]) { + return scip::ObjConshdlr::scip_sepalp(scip,conshdlr,conss,nconss,nusefulconss,result); + } + swigjobj = swig_get_self(jenv); + if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { + *((SCIP **)&jscip) = (SCIP *) scip; + *((SCIP_CONSHDLR **)&jconshdlr) = (SCIP_CONSHDLR *) conshdlr; + *((SCIP_CONS ***)&jconss) = (SCIP_CONS **) conss; + jnconss = (jint) nconss; + jnusefulconss = (jint) nusefulconss; + *((SCIP_Result **)&jresult) = (SCIP_Result *) result; + jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SCIPJNIJNI, Swig::director_method_ids[22], swigjobj, jscip, jconshdlr, jconss, jnconss, jnusefulconss, jresult); + jthrowable swigerror = jenv->ExceptionOccurred(); + if (swigerror) { + Swig::DirectorException::raise(jenv, swigerror); + } + + c_result = (SCIP_RETCODE)jresult; + } else { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in scip::ObjConshdlr::scip_sepalp "); + } + if (swigjobj) jenv->DeleteLocalRef(swigjobj); + return c_result; +} + +SCIP_RETCODE SwigDirector_ObjConshdlr::scip_sepasol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, int nusefulconss, SCIP_SOL *sol, SCIP_Result *result) { + SCIP_RETCODE c_result = SwigValueInit< SCIP_RETCODE >() ; + jint jresult = 0 ; + JNIEnvWrapper swigjnienv(this) ; + JNIEnv * jenv = swigjnienv.getJNIEnv() ; + jobject swigjobj = (jobject) NULL ; + jlong jscip = 0 ; + jlong jconshdlr = 0 ; + jlong jconss = 0 ; + jint jnconss ; + jint jnusefulconss ; + jlong jsol = 0 ; + + if (!swig_override[11]) { + return scip::ObjConshdlr::scip_sepasol(scip,conshdlr,conss,nconss,nusefulconss,sol,result); + } + swigjobj = swig_get_self(jenv); + if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { + *((SCIP **)&jscip) = (SCIP *) scip; + *((SCIP_CONSHDLR **)&jconshdlr) = (SCIP_CONSHDLR *) conshdlr; + *((SCIP_CONS ***)&jconss) = (SCIP_CONS **) conss; + jnconss = (jint) nconss; + jnusefulconss = (jint) nusefulconss; + *((SCIP_SOL **)&jsol) = (SCIP_SOL *) sol; + *((SCIP_Result **)&jresult) = (SCIP_Result *) result; + jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SCIPJNIJNI, Swig::director_method_ids[23], swigjobj, jscip, jconshdlr, jconss, jnconss, jnusefulconss, jsol, jresult); + jthrowable swigerror = jenv->ExceptionOccurred(); + if (swigerror) { + Swig::DirectorException::raise(jenv, swigerror); + } + + c_result = (SCIP_RETCODE)jresult; + } else { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in scip::ObjConshdlr::scip_sepasol "); + } + if (swigjobj) jenv->DeleteLocalRef(swigjobj); + return c_result; +} + +SCIP_RETCODE SwigDirector_ObjConshdlr::scip_enfolp(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, int nusefulconss, unsigned int solinfeasible, SCIP_Result *result) { + SCIP_RETCODE c_result = SwigValueInit< SCIP_RETCODE >() ; + jint jresult = 0 ; + JNIEnvWrapper swigjnienv(this) ; + JNIEnv * jenv = swigjnienv.getJNIEnv() ; + jobject swigjobj = (jobject) NULL ; + jlong jscip = 0 ; + jlong jconshdlr = 0 ; + jlong jconss = 0 ; + jint jnconss ; + jint jnusefulconss ; + jlong jsolinfeasible ; + + if (!swig_override[12]) { + return scip::ObjConshdlr::scip_enfolp(scip,conshdlr,conss,nconss,nusefulconss,solinfeasible,result); + } + swigjobj = swig_get_self(jenv); + if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { + *((SCIP **)&jscip) = (SCIP *) scip; + *((SCIP_CONSHDLR **)&jconshdlr) = (SCIP_CONSHDLR *) conshdlr; + *((SCIP_CONS ***)&jconss) = (SCIP_CONS **) conss; + jnconss = (jint) nconss; + jnusefulconss = (jint) nusefulconss; + jsolinfeasible = (jlong) solinfeasible; + *((SCIP_Result **)&jresult) = (SCIP_Result *) result; + jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SCIPJNIJNI, Swig::director_method_ids[24], swigjobj, jscip, jconshdlr, jconss, jnconss, jnusefulconss, jsolinfeasible, jresult); + jthrowable swigerror = jenv->ExceptionOccurred(); + if (swigerror) { + Swig::DirectorException::raise(jenv, swigerror); + } + + c_result = (SCIP_RETCODE)jresult; + } else { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in scip::ObjConshdlr::scip_enfolp "); + } + if (swigjobj) jenv->DeleteLocalRef(swigjobj); + return c_result; +} + +SCIP_RETCODE SwigDirector_ObjConshdlr::scip_enforelax(SCIP *scip, SCIP_SOL *sol, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, int nusefulconss, unsigned int solinfeasible, SCIP_Result *result) { + SCIP_RETCODE c_result = SwigValueInit< SCIP_RETCODE >() ; + jint jresult = 0 ; + JNIEnvWrapper swigjnienv(this) ; + JNIEnv * jenv = swigjnienv.getJNIEnv() ; + jobject swigjobj = (jobject) NULL ; + jlong jscip = 0 ; + jlong jsol = 0 ; + jlong jconshdlr = 0 ; + jlong jconss = 0 ; + jint jnconss ; + jint jnusefulconss ; + jlong jsolinfeasible ; + + if (!swig_override[13]) { + return scip::ObjConshdlr::scip_enforelax(scip,sol,conshdlr,conss,nconss,nusefulconss,solinfeasible,result); + } + swigjobj = swig_get_self(jenv); + if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { + *((SCIP **)&jscip) = (SCIP *) scip; + *((SCIP_SOL **)&jsol) = (SCIP_SOL *) sol; + *((SCIP_CONSHDLR **)&jconshdlr) = (SCIP_CONSHDLR *) conshdlr; + *((SCIP_CONS ***)&jconss) = (SCIP_CONS **) conss; + jnconss = (jint) nconss; + jnusefulconss = (jint) nusefulconss; + jsolinfeasible = (jlong) solinfeasible; + *((SCIP_Result **)&jresult) = (SCIP_Result *) result; + jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SCIPJNIJNI, Swig::director_method_ids[25], swigjobj, jscip, jsol, jconshdlr, jconss, jnconss, jnusefulconss, jsolinfeasible, jresult); + jthrowable swigerror = jenv->ExceptionOccurred(); + if (swigerror) { + Swig::DirectorException::raise(jenv, swigerror); + } + + c_result = (SCIP_RETCODE)jresult; + } else { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in scip::ObjConshdlr::scip_enforelax "); + } + if (swigjobj) jenv->DeleteLocalRef(swigjobj); + return c_result; +} + +SCIP_RETCODE SwigDirector_ObjConshdlr::scip_enfops(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, int nusefulconss, unsigned int solinfeasible, unsigned int objinfeasible, SCIP_Result *result) { + SCIP_RETCODE c_result = SwigValueInit< SCIP_RETCODE >() ; + jint jresult = 0 ; + JNIEnvWrapper swigjnienv(this) ; + JNIEnv * jenv = swigjnienv.getJNIEnv() ; + jobject swigjobj = (jobject) NULL ; + jlong jscip = 0 ; + jlong jconshdlr = 0 ; + jlong jconss = 0 ; + jint jnconss ; + jint jnusefulconss ; + jlong jsolinfeasible ; + jlong jobjinfeasible ; + + if (!swig_override[14]) { + return scip::ObjConshdlr::scip_enfops(scip,conshdlr,conss,nconss,nusefulconss,solinfeasible,objinfeasible,result); + } + swigjobj = swig_get_self(jenv); + if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { + *((SCIP **)&jscip) = (SCIP *) scip; + *((SCIP_CONSHDLR **)&jconshdlr) = (SCIP_CONSHDLR *) conshdlr; + *((SCIP_CONS ***)&jconss) = (SCIP_CONS **) conss; + jnconss = (jint) nconss; + jnusefulconss = (jint) nusefulconss; + jsolinfeasible = (jlong) solinfeasible; + jobjinfeasible = (jlong) objinfeasible; + *((SCIP_Result **)&jresult) = (SCIP_Result *) result; + jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SCIPJNIJNI, Swig::director_method_ids[26], swigjobj, jscip, jconshdlr, jconss, jnconss, jnusefulconss, jsolinfeasible, jobjinfeasible, jresult); + jthrowable swigerror = jenv->ExceptionOccurred(); + if (swigerror) { + Swig::DirectorException::raise(jenv, swigerror); + } + + c_result = (SCIP_RETCODE)jresult; + } else { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in scip::ObjConshdlr::scip_enfops "); + } + if (swigjobj) jenv->DeleteLocalRef(swigjobj); + return c_result; +} + +SCIP_RETCODE SwigDirector_ObjConshdlr::scip_check(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, SCIP_SOL *sol, unsigned int checkintegrality, unsigned int checklprows, unsigned int printreason, unsigned int completely, SCIP_Result *result) { + SCIP_RETCODE c_result = SwigValueInit< SCIP_RETCODE >() ; + jint jresult = 0 ; + JNIEnvWrapper swigjnienv(this) ; + JNIEnv * jenv = swigjnienv.getJNIEnv() ; + jobject swigjobj = (jobject) NULL ; + jlong jscip = 0 ; + jlong jconshdlr = 0 ; + jlong jconss = 0 ; + jint jnconss ; + jlong jsol = 0 ; + jlong jcheckintegrality ; + jlong jchecklprows ; + jlong jprintreason ; + jlong jcompletely ; + + if (!swig_override[15]) { + return scip::ObjConshdlr::scip_check(scip,conshdlr,conss,nconss,sol,checkintegrality,checklprows,printreason,completely,result); + } + swigjobj = swig_get_self(jenv); + if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { + *((SCIP **)&jscip) = (SCIP *) scip; + *((SCIP_CONSHDLR **)&jconshdlr) = (SCIP_CONSHDLR *) conshdlr; + *((SCIP_CONS ***)&jconss) = (SCIP_CONS **) conss; + jnconss = (jint) nconss; + *((SCIP_SOL **)&jsol) = (SCIP_SOL *) sol; + jcheckintegrality = (jlong) checkintegrality; + jchecklprows = (jlong) checklprows; + jprintreason = (jlong) printreason; + jcompletely = (jlong) completely; + *((SCIP_Result **)&jresult) = (SCIP_Result *) result; + jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SCIPJNIJNI, Swig::director_method_ids[27], swigjobj, jscip, jconshdlr, jconss, jnconss, jsol, jcheckintegrality, jchecklprows, jprintreason, jcompletely, jresult); + jthrowable swigerror = jenv->ExceptionOccurred(); + if (swigerror) { + Swig::DirectorException::raise(jenv, swigerror); + } + + c_result = (SCIP_RETCODE)jresult; + } else { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in scip::ObjConshdlr::scip_check "); + } + if (swigjobj) jenv->DeleteLocalRef(swigjobj); + return c_result; +} + +SCIP_RETCODE SwigDirector_ObjConshdlr::scip_prop(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, int nusefulconss, int nmarkedconss, SCIP_PROPTIMING proptiming, SCIP_Result *result) { + SCIP_RETCODE c_result = SwigValueInit< SCIP_RETCODE >() ; + jint jresult = 0 ; + JNIEnvWrapper swigjnienv(this) ; + JNIEnv * jenv = swigjnienv.getJNIEnv() ; + jobject swigjobj = (jobject) NULL ; + jlong jscip = 0 ; + jlong jconshdlr = 0 ; + jlong jconss = 0 ; + jint jnconss ; + jint jnusefulconss ; + jint jnmarkedconss ; + jlong jproptiming ; + + if (!swig_override[16]) { + return scip::ObjConshdlr::scip_prop(scip,conshdlr,conss,nconss,nusefulconss,nmarkedconss,proptiming,result); + } + swigjobj = swig_get_self(jenv); + if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { + *((SCIP **)&jscip) = (SCIP *) scip; + *((SCIP_CONSHDLR **)&jconshdlr) = (SCIP_CONSHDLR *) conshdlr; + *((SCIP_CONS ***)&jconss) = (SCIP_CONS **) conss; + jnconss = (jint) nconss; + jnusefulconss = (jint) nusefulconss; + jnmarkedconss = (jint) nmarkedconss; + jproptiming = 0; + *((SCIP_PROPTIMING **)&jproptiming) = new SCIP_PROPTIMING((const SCIP_PROPTIMING &)proptiming); + *((SCIP_Result **)&jresult) = (SCIP_Result *) result; + jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SCIPJNIJNI, Swig::director_method_ids[28], swigjobj, jscip, jconshdlr, jconss, jnconss, jnusefulconss, jnmarkedconss, jproptiming, jresult); + jthrowable swigerror = jenv->ExceptionOccurred(); + if (swigerror) { + Swig::DirectorException::raise(jenv, swigerror); + } + + c_result = (SCIP_RETCODE)jresult; + } else { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in scip::ObjConshdlr::scip_prop "); + } + if (swigjobj) jenv->DeleteLocalRef(swigjobj); + return c_result; +} + +SCIP_RETCODE SwigDirector_ObjConshdlr::scip_presol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, int nrounds, SCIP_PRESOLTIMING presoltiming, int nnewfixedvars, int nnewaggrvars, int nnewchgvartypes, int nnewchgbds, int nnewholes, int nnewdelconss, int nnewaddconss, int nnewupgdconss, int nnewchgcoefs, int nnewchgsides, int *nfixedvars, int *naggrvars, int *nchgvartypes, int *nchgbds, int *naddholes, int *ndelconss, int *naddconss, int *nupgdconss, int *nchgcoefs, int *nchgsides, SCIP_Result *result) { + SCIP_RETCODE c_result = SwigValueInit< SCIP_RETCODE >() ; + jint jresult = 0 ; + JNIEnvWrapper swigjnienv(this) ; + JNIEnv * jenv = swigjnienv.getJNIEnv() ; + jobject swigjobj = (jobject) NULL ; + jlong jscip = 0 ; + jlong jconshdlr = 0 ; + jlong jconss = 0 ; + jint jnconss ; + jint jnrounds ; + jlong jpresoltiming ; + jint jnnewfixedvars ; + jint jnnewaggrvars ; + jint jnnewchgvartypes ; + jint jnnewchgbds ; + jint jnnewholes ; + jint jnnewdelconss ; + jint jnnewaddconss ; + jint jnnewupgdconss ; + jint jnnewchgcoefs ; + jint jnnewchgsides ; + jlong jnfixedvars = 0 ; + jlong jnaggrvars = 0 ; + jlong jnchgvartypes = 0 ; + jlong jnchgbds = 0 ; + jlong jnaddholes = 0 ; + jlong jndelconss = 0 ; + jlong jnaddconss = 0 ; + jlong jnupgdconss = 0 ; + jlong jnchgcoefs = 0 ; + jlong jnchgsides = 0 ; + + if (!swig_override[17]) { + return scip::ObjConshdlr::scip_presol(scip,conshdlr,conss,nconss,nrounds,presoltiming,nnewfixedvars,nnewaggrvars,nnewchgvartypes,nnewchgbds,nnewholes,nnewdelconss,nnewaddconss,nnewupgdconss,nnewchgcoefs,nnewchgsides,nfixedvars,naggrvars,nchgvartypes,nchgbds,naddholes,ndelconss,naddconss,nupgdconss,nchgcoefs,nchgsides,result); + } + swigjobj = swig_get_self(jenv); + if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { + *((SCIP **)&jscip) = (SCIP *) scip; + *((SCIP_CONSHDLR **)&jconshdlr) = (SCIP_CONSHDLR *) conshdlr; + *((SCIP_CONS ***)&jconss) = (SCIP_CONS **) conss; + jnconss = (jint) nconss; + jnrounds = (jint) nrounds; + jpresoltiming = 0; + *((SCIP_PRESOLTIMING **)&jpresoltiming) = new SCIP_PRESOLTIMING((const SCIP_PRESOLTIMING &)presoltiming); + jnnewfixedvars = (jint) nnewfixedvars; + jnnewaggrvars = (jint) nnewaggrvars; + jnnewchgvartypes = (jint) nnewchgvartypes; + jnnewchgbds = (jint) nnewchgbds; + jnnewholes = (jint) nnewholes; + jnnewdelconss = (jint) nnewdelconss; + jnnewaddconss = (jint) nnewaddconss; + jnnewupgdconss = (jint) nnewupgdconss; + jnnewchgcoefs = (jint) nnewchgcoefs; + jnnewchgsides = (jint) nnewchgsides; + *((int **)&jnfixedvars) = (int *) nfixedvars; + *((int **)&jnaggrvars) = (int *) naggrvars; + *((int **)&jnchgvartypes) = (int *) nchgvartypes; + *((int **)&jnchgbds) = (int *) nchgbds; + *((int **)&jnaddholes) = (int *) naddholes; + *((int **)&jndelconss) = (int *) ndelconss; + *((int **)&jnaddconss) = (int *) naddconss; + *((int **)&jnupgdconss) = (int *) nupgdconss; + *((int **)&jnchgcoefs) = (int *) nchgcoefs; + *((int **)&jnchgsides) = (int *) nchgsides; + *((SCIP_Result **)&jresult) = (SCIP_Result *) result; + jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SCIPJNIJNI, Swig::director_method_ids[29], swigjobj, jscip, jconshdlr, jconss, jnconss, jnrounds, jpresoltiming, jnnewfixedvars, jnnewaggrvars, jnnewchgvartypes, jnnewchgbds, jnnewholes, jnnewdelconss, jnnewaddconss, jnnewupgdconss, jnnewchgcoefs, jnnewchgsides, jnfixedvars, jnaggrvars, jnchgvartypes, jnchgbds, jnaddholes, jndelconss, jnaddconss, jnupgdconss, jnchgcoefs, jnchgsides, jresult); + jthrowable swigerror = jenv->ExceptionOccurred(); + if (swigerror) { + Swig::DirectorException::raise(jenv, swigerror); + } + + c_result = (SCIP_RETCODE)jresult; + } else { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in scip::ObjConshdlr::scip_presol "); + } + if (swigjobj) jenv->DeleteLocalRef(swigjobj); + return c_result; +} + +SCIP_RETCODE SwigDirector_ObjConshdlr::scip_resprop(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons, SCIP_VAR *infervar, int inferinfo, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, double relaxedbd, SCIP_Result *result) { + SCIP_RETCODE c_result = SwigValueInit< SCIP_RETCODE >() ; + jint jresult = 0 ; + JNIEnvWrapper swigjnienv(this) ; + JNIEnv * jenv = swigjnienv.getJNIEnv() ; + jobject swigjobj = (jobject) NULL ; + jlong jscip = 0 ; + jlong jconshdlr = 0 ; + jlong jcons = 0 ; + jlong jinfervar = 0 ; + jint jinferinfo ; + jint jboundtype ; + jlong jbdchgidx = 0 ; + jdouble jrelaxedbd ; + + if (!swig_override[18]) { + return scip::ObjConshdlr::scip_resprop(scip,conshdlr,cons,infervar,inferinfo,boundtype,bdchgidx,relaxedbd,result); + } + swigjobj = swig_get_self(jenv); + if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { + *((SCIP **)&jscip) = (SCIP *) scip; + *((SCIP_CONSHDLR **)&jconshdlr) = (SCIP_CONSHDLR *) conshdlr; + *((SCIP_CONS **)&jcons) = (SCIP_CONS *) cons; + *((SCIP_VAR **)&jinfervar) = (SCIP_VAR *) infervar; + jinferinfo = (jint) inferinfo; + jboundtype = (jint) boundtype; + *((SCIP_BDCHGIDX **)&jbdchgidx) = (SCIP_BDCHGIDX *) bdchgidx; + jrelaxedbd = (jdouble) relaxedbd; + *((SCIP_Result **)&jresult) = (SCIP_Result *) result; + jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SCIPJNIJNI, Swig::director_method_ids[30], swigjobj, jscip, jconshdlr, jcons, jinfervar, jinferinfo, jboundtype, jbdchgidx, jrelaxedbd, jresult); + jthrowable swigerror = jenv->ExceptionOccurred(); + if (swigerror) { + Swig::DirectorException::raise(jenv, swigerror); + } + + c_result = (SCIP_RETCODE)jresult; + } else { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in scip::ObjConshdlr::scip_resprop "); + } + if (swigjobj) jenv->DeleteLocalRef(swigjobj); + return c_result; +} + +SCIP_RETCODE SwigDirector_ObjConshdlr::scip_lock(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons, SCIP_LockType locktype, int nlockspos, int nlocksneg) { + SCIP_RETCODE c_result = SwigValueInit< SCIP_RETCODE >() ; + jint jresult = 0 ; + JNIEnvWrapper swigjnienv(this) ; + JNIEnv * jenv = swigjnienv.getJNIEnv() ; + jobject swigjobj = (jobject) NULL ; + jlong jscip = 0 ; + jlong jconshdlr = 0 ; + jlong jcons = 0 ; + jint jlocktype ; + jint jnlockspos ; + jint jnlocksneg ; + + if (!swig_override[19]) { + return scip::ObjConshdlr::scip_lock(scip,conshdlr,cons,locktype,nlockspos,nlocksneg); + } + swigjobj = swig_get_self(jenv); + if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { + *((SCIP **)&jscip) = (SCIP *) scip; + *((SCIP_CONSHDLR **)&jconshdlr) = (SCIP_CONSHDLR *) conshdlr; + *((SCIP_CONS **)&jcons) = (SCIP_CONS *) cons; + jlocktype = (jint) locktype; + jnlockspos = (jint) nlockspos; + jnlocksneg = (jint) nlocksneg; + jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SCIPJNIJNI, Swig::director_method_ids[31], swigjobj, jscip, jconshdlr, jcons, jlocktype, jnlockspos, jnlocksneg); + jthrowable swigerror = jenv->ExceptionOccurred(); + if (swigerror) { + Swig::DirectorException::raise(jenv, swigerror); + } + + c_result = (SCIP_RETCODE)jresult; + } else { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in scip::ObjConshdlr::scip_lock "); + } + if (swigjobj) jenv->DeleteLocalRef(swigjobj); + return c_result; +} + +SCIP_RETCODE SwigDirector_ObjConshdlr::scip_active(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons) { + SCIP_RETCODE c_result = SwigValueInit< SCIP_RETCODE >() ; + jint jresult = 0 ; + JNIEnvWrapper swigjnienv(this) ; + JNIEnv * jenv = swigjnienv.getJNIEnv() ; + jobject swigjobj = (jobject) NULL ; + jlong jscip = 0 ; + jlong jconshdlr = 0 ; + jlong jcons = 0 ; + + if (!swig_override[20]) { + return scip::ObjConshdlr::scip_active(scip,conshdlr,cons); + } + swigjobj = swig_get_self(jenv); + if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { + *((SCIP **)&jscip) = (SCIP *) scip; + *((SCIP_CONSHDLR **)&jconshdlr) = (SCIP_CONSHDLR *) conshdlr; + *((SCIP_CONS **)&jcons) = (SCIP_CONS *) cons; + jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SCIPJNIJNI, Swig::director_method_ids[32], swigjobj, jscip, jconshdlr, jcons); + jthrowable swigerror = jenv->ExceptionOccurred(); + if (swigerror) { + Swig::DirectorException::raise(jenv, swigerror); + } + + c_result = (SCIP_RETCODE)jresult; + } else { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in scip::ObjConshdlr::scip_active "); + } + if (swigjobj) jenv->DeleteLocalRef(swigjobj); + return c_result; +} + +SCIP_RETCODE SwigDirector_ObjConshdlr::scip_deactive(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons) { + SCIP_RETCODE c_result = SwigValueInit< SCIP_RETCODE >() ; + jint jresult = 0 ; + JNIEnvWrapper swigjnienv(this) ; + JNIEnv * jenv = swigjnienv.getJNIEnv() ; + jobject swigjobj = (jobject) NULL ; + jlong jscip = 0 ; + jlong jconshdlr = 0 ; + jlong jcons = 0 ; + + if (!swig_override[21]) { + return scip::ObjConshdlr::scip_deactive(scip,conshdlr,cons); + } + swigjobj = swig_get_self(jenv); + if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { + *((SCIP **)&jscip) = (SCIP *) scip; + *((SCIP_CONSHDLR **)&jconshdlr) = (SCIP_CONSHDLR *) conshdlr; + *((SCIP_CONS **)&jcons) = (SCIP_CONS *) cons; + jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SCIPJNIJNI, Swig::director_method_ids[33], swigjobj, jscip, jconshdlr, jcons); + jthrowable swigerror = jenv->ExceptionOccurred(); + if (swigerror) { + Swig::DirectorException::raise(jenv, swigerror); + } + + c_result = (SCIP_RETCODE)jresult; + } else { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in scip::ObjConshdlr::scip_deactive "); + } + if (swigjobj) jenv->DeleteLocalRef(swigjobj); + return c_result; +} + +SCIP_RETCODE SwigDirector_ObjConshdlr::scip_enable(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons) { + SCIP_RETCODE c_result = SwigValueInit< SCIP_RETCODE >() ; + jint jresult = 0 ; + JNIEnvWrapper swigjnienv(this) ; + JNIEnv * jenv = swigjnienv.getJNIEnv() ; + jobject swigjobj = (jobject) NULL ; + jlong jscip = 0 ; + jlong jconshdlr = 0 ; + jlong jcons = 0 ; + + if (!swig_override[22]) { + return scip::ObjConshdlr::scip_enable(scip,conshdlr,cons); + } + swigjobj = swig_get_self(jenv); + if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { + *((SCIP **)&jscip) = (SCIP *) scip; + *((SCIP_CONSHDLR **)&jconshdlr) = (SCIP_CONSHDLR *) conshdlr; + *((SCIP_CONS **)&jcons) = (SCIP_CONS *) cons; + jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SCIPJNIJNI, Swig::director_method_ids[34], swigjobj, jscip, jconshdlr, jcons); + jthrowable swigerror = jenv->ExceptionOccurred(); + if (swigerror) { + Swig::DirectorException::raise(jenv, swigerror); + } + + c_result = (SCIP_RETCODE)jresult; + } else { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in scip::ObjConshdlr::scip_enable "); + } + if (swigjobj) jenv->DeleteLocalRef(swigjobj); + return c_result; +} + +SCIP_RETCODE SwigDirector_ObjConshdlr::scip_disable(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons) { + SCIP_RETCODE c_result = SwigValueInit< SCIP_RETCODE >() ; + jint jresult = 0 ; + JNIEnvWrapper swigjnienv(this) ; + JNIEnv * jenv = swigjnienv.getJNIEnv() ; + jobject swigjobj = (jobject) NULL ; + jlong jscip = 0 ; + jlong jconshdlr = 0 ; + jlong jcons = 0 ; + + if (!swig_override[23]) { + return scip::ObjConshdlr::scip_disable(scip,conshdlr,cons); + } + swigjobj = swig_get_self(jenv); + if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { + *((SCIP **)&jscip) = (SCIP *) scip; + *((SCIP_CONSHDLR **)&jconshdlr) = (SCIP_CONSHDLR *) conshdlr; + *((SCIP_CONS **)&jcons) = (SCIP_CONS *) cons; + jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SCIPJNIJNI, Swig::director_method_ids[35], swigjobj, jscip, jconshdlr, jcons); + jthrowable swigerror = jenv->ExceptionOccurred(); + if (swigerror) { + Swig::DirectorException::raise(jenv, swigerror); + } + + c_result = (SCIP_RETCODE)jresult; + } else { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in scip::ObjConshdlr::scip_disable "); + } + if (swigjobj) jenv->DeleteLocalRef(swigjobj); + return c_result; +} + +SCIP_RETCODE SwigDirector_ObjConshdlr::scip_delvars(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss) { + SCIP_RETCODE c_result = SwigValueInit< SCIP_RETCODE >() ; + jint jresult = 0 ; + JNIEnvWrapper swigjnienv(this) ; + JNIEnv * jenv = swigjnienv.getJNIEnv() ; + jobject swigjobj = (jobject) NULL ; + jlong jscip = 0 ; + jlong jconshdlr = 0 ; + jlong jconss = 0 ; + jint jnconss ; + + if (!swig_override[24]) { + return scip::ObjConshdlr::scip_delvars(scip,conshdlr,conss,nconss); + } + swigjobj = swig_get_self(jenv); + if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { + *((SCIP **)&jscip) = (SCIP *) scip; + *((SCIP_CONSHDLR **)&jconshdlr) = (SCIP_CONSHDLR *) conshdlr; + *((SCIP_CONS ***)&jconss) = (SCIP_CONS **) conss; + jnconss = (jint) nconss; + jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SCIPJNIJNI, Swig::director_method_ids[36], swigjobj, jscip, jconshdlr, jconss, jnconss); + jthrowable swigerror = jenv->ExceptionOccurred(); + if (swigerror) { + Swig::DirectorException::raise(jenv, swigerror); + } + + c_result = (SCIP_RETCODE)jresult; + } else { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in scip::ObjConshdlr::scip_delvars "); + } + if (swigjobj) jenv->DeleteLocalRef(swigjobj); + return c_result; +} + +SCIP_RETCODE SwigDirector_ObjConshdlr::scip_print(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons, FILE *file) { + SCIP_RETCODE c_result = SwigValueInit< SCIP_RETCODE >() ; + jint jresult = 0 ; + JNIEnvWrapper swigjnienv(this) ; + JNIEnv * jenv = swigjnienv.getJNIEnv() ; + jobject swigjobj = (jobject) NULL ; + jlong jscip = 0 ; + jlong jconshdlr = 0 ; + jlong jcons = 0 ; + jlong jfile = 0 ; + + if (!swig_override[25]) { + return scip::ObjConshdlr::scip_print(scip,conshdlr,cons,file); + } + swigjobj = swig_get_self(jenv); + if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { + *((SCIP **)&jscip) = (SCIP *) scip; + *((SCIP_CONSHDLR **)&jconshdlr) = (SCIP_CONSHDLR *) conshdlr; + *((SCIP_CONS **)&jcons) = (SCIP_CONS *) cons; + *((FILE **)&jfile) = (FILE *) file; + jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SCIPJNIJNI, Swig::director_method_ids[37], swigjobj, jscip, jconshdlr, jcons, jfile); + jthrowable swigerror = jenv->ExceptionOccurred(); + if (swigerror) { + Swig::DirectorException::raise(jenv, swigerror); + } + + c_result = (SCIP_RETCODE)jresult; + } else { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in scip::ObjConshdlr::scip_print "); + } + if (swigjobj) jenv->DeleteLocalRef(swigjobj); + return c_result; +} + +SCIP_RETCODE SwigDirector_ObjConshdlr::scip_copy(SCIP *scip, SCIP_CONS **cons, char const *name, SCIP *sourcescip, SCIP_CONSHDLR *sourceconshdlr, SCIP_CONS *sourcecons, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, unsigned int initial, unsigned int separate, unsigned int enforce, unsigned int check, unsigned int propagate, unsigned int local, unsigned int modifiable, unsigned int dynamic, unsigned int removable, unsigned int stickingatnode, unsigned int global, unsigned int *valid) { + SCIP_RETCODE c_result = SwigValueInit< SCIP_RETCODE >() ; + jint jresult = 0 ; + JNIEnvWrapper swigjnienv(this) ; + JNIEnv * jenv = swigjnienv.getJNIEnv() ; + jobject swigjobj = (jobject) NULL ; + jlong jscip = 0 ; + jlong jcons = 0 ; + jstring jname = 0 ; + jlong jsourcescip = 0 ; + jlong jsourceconshdlr = 0 ; + jlong jsourcecons = 0 ; + jlong jvarmap = 0 ; + jlong jconsmap = 0 ; + jlong jinitial ; + jlong jseparate ; + jlong jenforce ; + jlong jcheck ; + jlong jpropagate ; + jlong jlocal ; + jlong jmodifiable ; + jlong jdynamic ; + jlong jremovable ; + jlong jstickingatnode ; + jlong jglobal ; + jlong jvalid = 0 ; + + if (!swig_override[26]) { + return scip::ObjConshdlr::scip_copy(scip,cons,name,sourcescip,sourceconshdlr,sourcecons,varmap,consmap,initial,separate,enforce,check,propagate,local,modifiable,dynamic,removable,stickingatnode,global,valid); + } + swigjobj = swig_get_self(jenv); + if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { + *((SCIP **)&jscip) = (SCIP *) scip; + *((SCIP_CONS ***)&jcons) = (SCIP_CONS **) cons; + jname = 0; + if (name) { + jname = jenv->NewStringUTF((const char *)name); + if (!jname) return c_result; + } + Swig::LocalRefGuard name_refguard(jenv, jname); + *((SCIP **)&jsourcescip) = (SCIP *) sourcescip; + *((SCIP_CONSHDLR **)&jsourceconshdlr) = (SCIP_CONSHDLR *) sourceconshdlr; + *((SCIP_CONS **)&jsourcecons) = (SCIP_CONS *) sourcecons; + *((SCIP_HASHMAP **)&jvarmap) = (SCIP_HASHMAP *) varmap; + *((SCIP_HASHMAP **)&jconsmap) = (SCIP_HASHMAP *) consmap; + jinitial = (jlong) initial; + jseparate = (jlong) separate; + jenforce = (jlong) enforce; + jcheck = (jlong) check; + jpropagate = (jlong) propagate; + jlocal = (jlong) local; + jmodifiable = (jlong) modifiable; + jdynamic = (jlong) dynamic; + jremovable = (jlong) removable; + jstickingatnode = (jlong) stickingatnode; + jglobal = (jlong) global; + *((unsigned int **)&jvalid) = (unsigned int *) valid; + jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SCIPJNIJNI, Swig::director_method_ids[38], swigjobj, jscip, jcons, jname, jsourcescip, jsourceconshdlr, jsourcecons, jvarmap, jconsmap, jinitial, jseparate, jenforce, jcheck, jpropagate, jlocal, jmodifiable, jdynamic, jremovable, jstickingatnode, jglobal, jvalid); + jthrowable swigerror = jenv->ExceptionOccurred(); + if (swigerror) { + Swig::DirectorException::raise(jenv, swigerror); + } + + c_result = (SCIP_RETCODE)jresult; + } else { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in scip::ObjConshdlr::scip_copy "); + } + if (swigjobj) jenv->DeleteLocalRef(swigjobj); + return c_result; +} + +SCIP_RETCODE SwigDirector_ObjConshdlr::scip_parse(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **cons, char const *name, char const *str, unsigned int initial, unsigned int separate, unsigned int enforce, unsigned int check, unsigned int propagate, unsigned int local, unsigned int modifiable, unsigned int dynamic, unsigned int removable, unsigned int stickingatnode, unsigned int *success) { + SCIP_RETCODE c_result = SwigValueInit< SCIP_RETCODE >() ; + jint jresult = 0 ; + JNIEnvWrapper swigjnienv(this) ; + JNIEnv * jenv = swigjnienv.getJNIEnv() ; + jobject swigjobj = (jobject) NULL ; + jlong jscip = 0 ; + jlong jconshdlr = 0 ; + jlong jcons = 0 ; + jstring jname = 0 ; + jstring jstr = 0 ; + jlong jinitial ; + jlong jseparate ; + jlong jenforce ; + jlong jcheck ; + jlong jpropagate ; + jlong jlocal ; + jlong jmodifiable ; + jlong jdynamic ; + jlong jremovable ; + jlong jstickingatnode ; + jlong jsuccess = 0 ; + + if (!swig_override[27]) { + return scip::ObjConshdlr::scip_parse(scip,conshdlr,cons,name,str,initial,separate,enforce,check,propagate,local,modifiable,dynamic,removable,stickingatnode,success); + } + swigjobj = swig_get_self(jenv); + if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { + *((SCIP **)&jscip) = (SCIP *) scip; + *((SCIP_CONSHDLR **)&jconshdlr) = (SCIP_CONSHDLR *) conshdlr; + *((SCIP_CONS ***)&jcons) = (SCIP_CONS **) cons; + jname = 0; + if (name) { + jname = jenv->NewStringUTF((const char *)name); + if (!jname) return c_result; + } + Swig::LocalRefGuard name_refguard(jenv, jname); + jstr = 0; + if (str) { + jstr = jenv->NewStringUTF((const char *)str); + if (!jstr) return c_result; + } + Swig::LocalRefGuard str_refguard(jenv, jstr); + jinitial = (jlong) initial; + jseparate = (jlong) separate; + jenforce = (jlong) enforce; + jcheck = (jlong) check; + jpropagate = (jlong) propagate; + jlocal = (jlong) local; + jmodifiable = (jlong) modifiable; + jdynamic = (jlong) dynamic; + jremovable = (jlong) removable; + jstickingatnode = (jlong) stickingatnode; + *((unsigned int **)&jsuccess) = (unsigned int *) success; + jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SCIPJNIJNI, Swig::director_method_ids[39], swigjobj, jscip, jconshdlr, jcons, jname, jstr, jinitial, jseparate, jenforce, jcheck, jpropagate, jlocal, jmodifiable, jdynamic, jremovable, jstickingatnode, jsuccess); + jthrowable swigerror = jenv->ExceptionOccurred(); + if (swigerror) { + Swig::DirectorException::raise(jenv, swigerror); + } + + c_result = (SCIP_RETCODE)jresult; + } else { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in scip::ObjConshdlr::scip_parse "); + } + if (swigjobj) jenv->DeleteLocalRef(swigjobj); + return c_result; +} + +SCIP_RETCODE SwigDirector_ObjConshdlr::scip_getvars(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons, SCIP_VAR **vars, int varssize, unsigned int *success) { + SCIP_RETCODE c_result = SwigValueInit< SCIP_RETCODE >() ; + jint jresult = 0 ; + JNIEnvWrapper swigjnienv(this) ; + JNIEnv * jenv = swigjnienv.getJNIEnv() ; + jobject swigjobj = (jobject) NULL ; + jlong jscip = 0 ; + jlong jconshdlr = 0 ; + jlong jcons = 0 ; + jlong jvars = 0 ; + jint jvarssize ; + jlong jsuccess = 0 ; + + if (!swig_override[28]) { + return scip::ObjConshdlr::scip_getvars(scip,conshdlr,cons,vars,varssize,success); + } + swigjobj = swig_get_self(jenv); + if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { + *((SCIP **)&jscip) = (SCIP *) scip; + *((SCIP_CONSHDLR **)&jconshdlr) = (SCIP_CONSHDLR *) conshdlr; + *((SCIP_CONS **)&jcons) = (SCIP_CONS *) cons; + *((SCIP_VAR ***)&jvars) = (SCIP_VAR **) vars; + jvarssize = (jint) varssize; + *((unsigned int **)&jsuccess) = (unsigned int *) success; + jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SCIPJNIJNI, Swig::director_method_ids[40], swigjobj, jscip, jconshdlr, jcons, jvars, jvarssize, jsuccess); + jthrowable swigerror = jenv->ExceptionOccurred(); + if (swigerror) { + Swig::DirectorException::raise(jenv, swigerror); + } + + c_result = (SCIP_RETCODE)jresult; + } else { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in scip::ObjConshdlr::scip_getvars "); + } + if (swigjobj) jenv->DeleteLocalRef(swigjobj); + return c_result; +} + +SCIP_RETCODE SwigDirector_ObjConshdlr::scip_getnvars(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons, int *nvars, unsigned int *success) { + SCIP_RETCODE c_result = SwigValueInit< SCIP_RETCODE >() ; + jint jresult = 0 ; + JNIEnvWrapper swigjnienv(this) ; + JNIEnv * jenv = swigjnienv.getJNIEnv() ; + jobject swigjobj = (jobject) NULL ; + jlong jscip = 0 ; + jlong jconshdlr = 0 ; + jlong jcons = 0 ; + jlong jnvars = 0 ; + jlong jsuccess = 0 ; + + if (!swig_override[29]) { + return scip::ObjConshdlr::scip_getnvars(scip,conshdlr,cons,nvars,success); + } + swigjobj = swig_get_self(jenv); + if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { + *((SCIP **)&jscip) = (SCIP *) scip; + *((SCIP_CONSHDLR **)&jconshdlr) = (SCIP_CONSHDLR *) conshdlr; + *((SCIP_CONS **)&jcons) = (SCIP_CONS *) cons; + *((int **)&jnvars) = (int *) nvars; + *((unsigned int **)&jsuccess) = (unsigned int *) success; + jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SCIPJNIJNI, Swig::director_method_ids[41], swigjobj, jscip, jconshdlr, jcons, jnvars, jsuccess); + jthrowable swigerror = jenv->ExceptionOccurred(); + if (swigerror) { + Swig::DirectorException::raise(jenv, swigerror); + } + + c_result = (SCIP_RETCODE)jresult; + } else { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in scip::ObjConshdlr::scip_getnvars "); + } + if (swigjobj) jenv->DeleteLocalRef(swigjobj); + return c_result; +} + +SCIP_RETCODE SwigDirector_ObjConshdlr::scip_getdivebdchgs(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DIVESET *diveset, SCIP_SOL *sol, unsigned int *success, unsigned int *infeasible) { + SCIP_RETCODE c_result = SwigValueInit< SCIP_RETCODE >() ; + jint jresult = 0 ; + JNIEnvWrapper swigjnienv(this) ; + JNIEnv * jenv = swigjnienv.getJNIEnv() ; + jobject swigjobj = (jobject) NULL ; + jlong jscip = 0 ; + jlong jconshdlr = 0 ; + jlong jdiveset = 0 ; + jlong jsol = 0 ; + jlong jsuccess = 0 ; + jlong jinfeasible = 0 ; + + if (!swig_override[30]) { + return scip::ObjConshdlr::scip_getdivebdchgs(scip,conshdlr,diveset,sol,success,infeasible); + } + swigjobj = swig_get_self(jenv); + if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { + *((SCIP **)&jscip) = (SCIP *) scip; + *((SCIP_CONSHDLR **)&jconshdlr) = (SCIP_CONSHDLR *) conshdlr; + *((SCIP_DIVESET **)&jdiveset) = (SCIP_DIVESET *) diveset; + *((SCIP_SOL **)&jsol) = (SCIP_SOL *) sol; + *((unsigned int **)&jsuccess) = (unsigned int *) success; + *((unsigned int **)&jinfeasible) = (unsigned int *) infeasible; + jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SCIPJNIJNI, Swig::director_method_ids[42], swigjobj, jscip, jconshdlr, jdiveset, jsol, jsuccess, jinfeasible); + jthrowable swigerror = jenv->ExceptionOccurred(); + if (swigerror) { + Swig::DirectorException::raise(jenv, swigerror); + } + + c_result = (SCIP_RETCODE)jresult; + } else { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in scip::ObjConshdlr::scip_getdivebdchgs "); + } + if (swigjobj) jenv->DeleteLocalRef(swigjobj); + return c_result; +} + +SCIP_RETCODE SwigDirector_ObjConshdlr::scip_getpermsymgraph(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons, SYM_GRAPH *graph, unsigned int *success) { + SCIP_RETCODE c_result = SwigValueInit< SCIP_RETCODE >() ; + jint jresult = 0 ; + JNIEnvWrapper swigjnienv(this) ; + JNIEnv * jenv = swigjnienv.getJNIEnv() ; + jobject swigjobj = (jobject) NULL ; + jlong jscip = 0 ; + jlong jconshdlr = 0 ; + jlong jcons = 0 ; + jlong jgraph = 0 ; + jlong jsuccess = 0 ; + + if (!swig_override[31]) { + return scip::ObjConshdlr::scip_getpermsymgraph(scip,conshdlr,cons,graph,success); + } + swigjobj = swig_get_self(jenv); + if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { + *((SCIP **)&jscip) = (SCIP *) scip; + *((SCIP_CONSHDLR **)&jconshdlr) = (SCIP_CONSHDLR *) conshdlr; + *((SCIP_CONS **)&jcons) = (SCIP_CONS *) cons; + *((SYM_GRAPH **)&jgraph) = (SYM_GRAPH *) graph; + *((unsigned int **)&jsuccess) = (unsigned int *) success; + jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SCIPJNIJNI, Swig::director_method_ids[43], swigjobj, jscip, jconshdlr, jcons, jgraph, jsuccess); + jthrowable swigerror = jenv->ExceptionOccurred(); + if (swigerror) { + Swig::DirectorException::raise(jenv, swigerror); + } + + c_result = (SCIP_RETCODE)jresult; + } else { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in scip::ObjConshdlr::scip_getpermsymgraph "); + } + if (swigjobj) jenv->DeleteLocalRef(swigjobj); + return c_result; +} + +SCIP_RETCODE SwigDirector_ObjConshdlr::scip_getsignedpermsymgraph(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons, SYM_GRAPH *graph, unsigned int *success) { + SCIP_RETCODE c_result = SwigValueInit< SCIP_RETCODE >() ; + jint jresult = 0 ; + JNIEnvWrapper swigjnienv(this) ; + JNIEnv * jenv = swigjnienv.getJNIEnv() ; + jobject swigjobj = (jobject) NULL ; + jlong jscip = 0 ; + jlong jconshdlr = 0 ; + jlong jcons = 0 ; + jlong jgraph = 0 ; + jlong jsuccess = 0 ; + + if (!swig_override[32]) { + return scip::ObjConshdlr::scip_getsignedpermsymgraph(scip,conshdlr,cons,graph,success); + } + swigjobj = swig_get_self(jenv); + if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { + *((SCIP **)&jscip) = (SCIP *) scip; + *((SCIP_CONSHDLR **)&jconshdlr) = (SCIP_CONSHDLR *) conshdlr; + *((SCIP_CONS **)&jcons) = (SCIP_CONS *) cons; + *((SYM_GRAPH **)&jgraph) = (SYM_GRAPH *) graph; + *((unsigned int **)&jsuccess) = (unsigned int *) success; + jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SCIPJNIJNI, Swig::director_method_ids[44], swigjobj, jscip, jconshdlr, jcons, jgraph, jsuccess); + jthrowable swigerror = jenv->ExceptionOccurred(); + if (swigerror) { + Swig::DirectorException::raise(jenv, swigerror); + } + + c_result = (SCIP_RETCODE)jresult; + } else { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in scip::ObjConshdlr::scip_getsignedpermsymgraph "); + } + if (swigjobj) jenv->DeleteLocalRef(swigjobj); + return c_result; +} + +void SwigDirector_ObjConshdlr::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) { + static struct { + const char *mname; + const char *mdesc; + jmethodID base_methid; + } methods[] = { + { + "scip_free", "(Ljscip/SWIGTYPE_p_SCIP;Ljscip/SWIGTYPE_p_SCIP_CONSHDLR;)Ljscip/SCIP_Retcode;", NULL + }, + { + "scip_init", "(Ljscip/SWIGTYPE_p_SCIP;Ljscip/SWIGTYPE_p_SCIP_CONSHDLR;Ljscip/SWIGTYPE_p_p_SCIP_CONS;I)Ljscip/SCIP_Retcode;", NULL + }, + { + "scip_exit", "(Ljscip/SWIGTYPE_p_SCIP;Ljscip/SWIGTYPE_p_SCIP_CONSHDLR;Ljscip/SWIGTYPE_p_p_SCIP_CONS;I)Ljscip/SCIP_Retcode;", NULL + }, + { + "scip_initpre", "(Ljscip/SWIGTYPE_p_SCIP;Ljscip/SWIGTYPE_p_SCIP_CONSHDLR;Ljscip/SWIGTYPE_p_p_SCIP_CONS;I)Ljscip/SCIP_Retcode;", NULL + }, + { + "scip_exitpre", "(Ljscip/SWIGTYPE_p_SCIP;Ljscip/SWIGTYPE_p_SCIP_CONSHDLR;Ljscip/SWIGTYPE_p_p_SCIP_CONS;I)Ljscip/SCIP_Retcode;", NULL + }, + { + "scip_initsol", "(Ljscip/SWIGTYPE_p_SCIP;Ljscip/SWIGTYPE_p_SCIP_CONSHDLR;Ljscip/SWIGTYPE_p_p_SCIP_CONS;I)Ljscip/SCIP_Retcode;", NULL + }, + { + "scip_exitsol", "(Ljscip/SWIGTYPE_p_SCIP;Ljscip/SWIGTYPE_p_SCIP_CONSHDLR;Ljscip/SWIGTYPE_p_p_SCIP_CONS;IJ)Ljscip/SCIP_Retcode;", NULL + }, + { + "scip_delete", "(Ljscip/SWIGTYPE_p_SCIP;Ljscip/SWIGTYPE_p_SCIP_CONSHDLR;Ljscip/SWIGTYPE_p_SCIP_CONS;Ljscip/SWIGTYPE_p_p_SCIP_CONSDATA;)Ljscip/SCIP_Retcode;", NULL + }, + { + "scip_trans", "(Ljscip/SWIGTYPE_p_SCIP;Ljscip/SWIGTYPE_p_SCIP_CONSHDLR;Ljscip/SWIGTYPE_p_SCIP_CONS;Ljscip/SWIGTYPE_p_p_SCIP_CONS;)Ljscip/SCIP_Retcode;", NULL + }, + { + "scip_initlp", "(Ljscip/SWIGTYPE_p_SCIP;Ljscip/SWIGTYPE_p_SCIP_CONSHDLR;Ljscip/SWIGTYPE_p_p_SCIP_CONS;ILjscip/SWIGTYPE_p_unsigned_int;)Ljscip/SCIP_Retcode;", NULL + }, + { + "scip_sepalp", "(Ljscip/SWIGTYPE_p_SCIP;Ljscip/SWIGTYPE_p_SCIP_CONSHDLR;Ljscip/SWIGTYPE_p_p_SCIP_CONS;IILjscip/SWIGTYPE_p_SCIP_Result;)Ljscip/SCIP_Retcode;", NULL + }, + { + "scip_sepasol", "(Ljscip/SWIGTYPE_p_SCIP;Ljscip/SWIGTYPE_p_SCIP_CONSHDLR;Ljscip/SWIGTYPE_p_p_SCIP_CONS;IILjscip/SWIGTYPE_p_SCIP_SOL;Ljscip/SWIGTYPE_p_SCIP_Result;)Ljscip/SCIP_Retcode;", NULL + }, + { + "scip_enfolp", "(Ljscip/SWIGTYPE_p_SCIP;Ljscip/SWIGTYPE_p_SCIP_CONSHDLR;Ljscip/SWIGTYPE_p_p_SCIP_CONS;IIJLjscip/SWIGTYPE_p_SCIP_Result;)Ljscip/SCIP_Retcode;", NULL + }, + { + "scip_enforelax", "(Ljscip/SWIGTYPE_p_SCIP;Ljscip/SWIGTYPE_p_SCIP_SOL;Ljscip/SWIGTYPE_p_SCIP_CONSHDLR;Ljscip/SWIGTYPE_p_p_SCIP_CONS;IIJLjscip/SWIGTYPE_p_SCIP_Result;)Ljscip/SCIP_Retcode;", NULL + }, + { + "scip_enfops", "(Ljscip/SWIGTYPE_p_SCIP;Ljscip/SWIGTYPE_p_SCIP_CONSHDLR;Ljscip/SWIGTYPE_p_p_SCIP_CONS;IIJJLjscip/SWIGTYPE_p_SCIP_Result;)Ljscip/SCIP_Retcode;", NULL + }, + { + "scip_check", "(Ljscip/SWIGTYPE_p_SCIP;Ljscip/SWIGTYPE_p_SCIP_CONSHDLR;Ljscip/SWIGTYPE_p_p_SCIP_CONS;ILjscip/SWIGTYPE_p_SCIP_SOL;JJJJLjscip/SWIGTYPE_p_SCIP_Result;)Ljscip/SCIP_Retcode;", NULL + }, + { + "scip_prop", "(Ljscip/SWIGTYPE_p_SCIP;Ljscip/SWIGTYPE_p_SCIP_CONSHDLR;Ljscip/SWIGTYPE_p_p_SCIP_CONS;IIILjscip/SWIGTYPE_p_SCIP_PROPTIMING;Ljscip/SWIGTYPE_p_SCIP_Result;)Ljscip/SCIP_Retcode;", NULL + }, + { + "scip_presol", "(Ljscip/SWIGTYPE_p_SCIP;Ljscip/SWIGTYPE_p_SCIP_CONSHDLR;Ljscip/SWIGTYPE_p_p_SCIP_CONS;IILjscip/SWIGTYPE_p_SCIP_PRESOLTIMING;IIIIIIIIIILjscip/SWIGTYPE_p_int;Ljscip/SWIGTYPE_p_int;Ljscip/SWIGTYPE_p_int;Ljscip/SWIGTYPE_p_int;Ljscip/SWIGTYPE_p_int;Ljscip/SWIGTYPE_p_int;Ljscip/SWIGTYPE_p_int;Ljscip/SWIGTYPE_p_int;Ljscip/SWIGTYPE_p_int;Ljscip/SWIGTYPE_p_int;Ljscip/SWIGTYPE_p_SCIP_Result;)Ljscip/SCIP_Retcode;", NULL + }, + { + "scip_resprop", "(Ljscip/SWIGTYPE_p_SCIP;Ljscip/SWIGTYPE_p_SCIP_CONSHDLR;Ljscip/SWIGTYPE_p_SCIP_CONS;Ljscip/SWIGTYPE_p_SCIP_VAR;ILjscip/SCIP_BoundType;Ljscip/SWIGTYPE_p_SCIP_BDCHGIDX;DLjscip/SWIGTYPE_p_SCIP_Result;)Ljscip/SCIP_Retcode;", NULL + }, + { + "scip_lock", "(Ljscip/SWIGTYPE_p_SCIP;Ljscip/SWIGTYPE_p_SCIP_CONSHDLR;Ljscip/SWIGTYPE_p_SCIP_CONS;Ljscip/SCIP_LockType;II)Ljscip/SCIP_Retcode;", NULL + }, + { + "scip_active", "(Ljscip/SWIGTYPE_p_SCIP;Ljscip/SWIGTYPE_p_SCIP_CONSHDLR;Ljscip/SWIGTYPE_p_SCIP_CONS;)Ljscip/SCIP_Retcode;", NULL + }, + { + "scip_deactive", "(Ljscip/SWIGTYPE_p_SCIP;Ljscip/SWIGTYPE_p_SCIP_CONSHDLR;Ljscip/SWIGTYPE_p_SCIP_CONS;)Ljscip/SCIP_Retcode;", NULL + }, + { + "scip_enable", "(Ljscip/SWIGTYPE_p_SCIP;Ljscip/SWIGTYPE_p_SCIP_CONSHDLR;Ljscip/SWIGTYPE_p_SCIP_CONS;)Ljscip/SCIP_Retcode;", NULL + }, + { + "scip_disable", "(Ljscip/SWIGTYPE_p_SCIP;Ljscip/SWIGTYPE_p_SCIP_CONSHDLR;Ljscip/SWIGTYPE_p_SCIP_CONS;)Ljscip/SCIP_Retcode;", NULL + }, + { + "scip_delvars", "(Ljscip/SWIGTYPE_p_SCIP;Ljscip/SWIGTYPE_p_SCIP_CONSHDLR;Ljscip/SWIGTYPE_p_p_SCIP_CONS;I)Ljscip/SCIP_Retcode;", NULL + }, + { + "scip_print", "(Ljscip/SWIGTYPE_p_SCIP;Ljscip/SWIGTYPE_p_SCIP_CONSHDLR;Ljscip/SWIGTYPE_p_SCIP_CONS;Ljscip/SWIGTYPE_p_FILE;)Ljscip/SCIP_Retcode;", NULL + }, + { + "scip_copy", "(Ljscip/SWIGTYPE_p_SCIP;Ljscip/SWIGTYPE_p_p_SCIP_CONS;Ljava/lang/String;Ljscip/SWIGTYPE_p_SCIP;Ljscip/SWIGTYPE_p_SCIP_CONSHDLR;Ljscip/SWIGTYPE_p_SCIP_CONS;Ljscip/SWIGTYPE_p_SCIP_HASHMAP;Ljscip/SWIGTYPE_p_SCIP_HASHMAP;JJJJJJJJJJJLjscip/SWIGTYPE_p_unsigned_int;)Ljscip/SCIP_Retcode;", NULL + }, + { + "scip_parse", "(Ljscip/SWIGTYPE_p_SCIP;Ljscip/SWIGTYPE_p_SCIP_CONSHDLR;Ljscip/SWIGTYPE_p_p_SCIP_CONS;Ljava/lang/String;Ljava/lang/String;JJJJJJJJJJLjscip/SWIGTYPE_p_unsigned_int;)Ljscip/SCIP_Retcode;", NULL + }, + { + "scip_getvars", "(Ljscip/SWIGTYPE_p_SCIP;Ljscip/SWIGTYPE_p_SCIP_CONSHDLR;Ljscip/SWIGTYPE_p_SCIP_CONS;Ljscip/SWIGTYPE_p_p_SCIP_VAR;ILjscip/SWIGTYPE_p_unsigned_int;)Ljscip/SCIP_Retcode;", NULL + }, + { + "scip_getnvars", "(Ljscip/SWIGTYPE_p_SCIP;Ljscip/SWIGTYPE_p_SCIP_CONSHDLR;Ljscip/SWIGTYPE_p_SCIP_CONS;Ljscip/SWIGTYPE_p_int;Ljscip/SWIGTYPE_p_unsigned_int;)Ljscip/SCIP_Retcode;", NULL + }, + { + "scip_getdivebdchgs", "(Ljscip/SWIGTYPE_p_SCIP;Ljscip/SWIGTYPE_p_SCIP_CONSHDLR;Ljscip/SWIGTYPE_p_SCIP_DIVESET;Ljscip/SWIGTYPE_p_SCIP_SOL;Ljscip/SWIGTYPE_p_unsigned_int;Ljscip/SWIGTYPE_p_unsigned_int;)Ljscip/SCIP_Retcode;", NULL + }, + { + "scip_getpermsymgraph", "(Ljscip/SWIGTYPE_p_SCIP;Ljscip/SWIGTYPE_p_SCIP_CONSHDLR;Ljscip/SWIGTYPE_p_SCIP_CONS;Ljscip/SWIGTYPE_p_SYM_GRAPH;Ljscip/SWIGTYPE_p_unsigned_int;)Ljscip/SCIP_Retcode;", NULL + }, + { + "scip_getsignedpermsymgraph", "(Ljscip/SWIGTYPE_p_SCIP;Ljscip/SWIGTYPE_p_SCIP_CONSHDLR;Ljscip/SWIGTYPE_p_SCIP_CONS;Ljscip/SWIGTYPE_p_SYM_GRAPH;Ljscip/SWIGTYPE_p_unsigned_int;)Ljscip/SCIP_Retcode;", NULL + } + }; + + static jclass baseclass = 0 ; + + if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) { + if (!baseclass) { + baseclass = jenv->FindClass("jscip/ObjConshdlr"); + if (!baseclass) return; + baseclass = (jclass) jenv->NewGlobalRef(baseclass); + } + bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true); + for (int i = 0; i < 33; ++i) { + if (!methods[i].base_methid) { + methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc); + if (!methods[i].base_methid) return; + } + swig_override[i] = false; + if (derived) { + jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc); + swig_override[i] = (methid != methods[i].base_methid); + jenv->ExceptionClear(); + } + } + } +} + + + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_new_1char_1array(JNIEnv *jenv, jclass jcls, jint jarg1) { + jlong jresult = 0 ; + int arg1 ; + char *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = (int)jarg1; + result = (char *)new_char_array(arg1); + *(char **)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_delete_1char_1array(JNIEnv *jenv, jclass jcls, jlong jarg1) { + char *arg1 = (char *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(char **)&jarg1; + delete_char_array(arg1); + +} + + +SWIGEXPORT jchar JNICALL Java_jscip_SCIPJNIJNI_char_1array_1getitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) { + jchar jresult = 0 ; + char *arg1 = (char *) 0 ; + int arg2 ; + char result; + + (void)jenv; + (void)jcls; + arg1 = *(char **)&jarg1; + arg2 = (int)jarg2; + result = (char)char_array_getitem(arg1,arg2); + jresult = (jchar)result; + + return jresult; +} + + +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_char_1array_1setitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2, jchar jarg3) { + char *arg1 = (char *) 0 ; + int arg2 ; + char arg3 ; + + (void)jenv; + (void)jcls; + arg1 = *(char **)&jarg1; + arg2 = (int)jarg2; + arg3 = (char)jarg3; + char_array_setitem(arg1,arg2,arg3); + +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_new_1double_1array(JNIEnv *jenv, jclass jcls, jint jarg1) { + jlong jresult = 0 ; + int arg1 ; + double *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = (int)jarg1; + result = (double *)new_double_array(arg1); + *(double **)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_delete_1double_1array(JNIEnv *jenv, jclass jcls, jlong jarg1) { + double *arg1 = (double *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(double **)&jarg1; + delete_double_array(arg1); +} + + +SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_double_1array_1getitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) { + jdouble jresult = 0 ; + double *arg1 = (double *) 0 ; + int arg2 ; + double result; + + (void)jenv; + (void)jcls; + arg1 = *(double **)&jarg1; + arg2 = (int)jarg2; + result = (double)double_array_getitem(arg1,arg2); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_double_1array_1setitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2, jdouble jarg3) { + double *arg1 = (double *) 0 ; + int arg2 ; + double arg3 ; + + (void)jenv; + (void)jcls; + arg1 = *(double **)&jarg1; + arg2 = (int)jarg2; + arg3 = (double)jarg3; + double_array_setitem(arg1,arg2,arg3); +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_new_1int_1array(JNIEnv *jenv, jclass jcls, jint jarg1) { + jlong jresult = 0 ; + int arg1 ; + int *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = (int)jarg1; + result = (int *)new_int_array(arg1); + *(int **)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_delete_1int_1array(JNIEnv *jenv, jclass jcls, jlong jarg1) { + int *arg1 = (int *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(int **)&jarg1; + delete_int_array(arg1); +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_int_1array_1getitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) { + jint jresult = 0 ; + int *arg1 = (int *) 0 ; + int arg2 ; + int result; + + (void)jenv; + (void)jcls; + arg1 = *(int **)&jarg1; + arg2 = (int)jarg2; + result = (int)int_array_getitem(arg1,arg2); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_int_1array_1setitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2, jint jarg3) { + int *arg1 = (int *) 0 ; + int arg2 ; + int arg3 ; + + (void)jenv; + (void)jcls; + arg1 = *(int **)&jarg1; + arg2 = (int)jarg2; + arg3 = (int)jarg3; + int_array_setitem(arg1,arg2,arg3); +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_new_1long_1long_1array(JNIEnv *jenv, jclass jcls, jint jarg1) { + jlong jresult = 0 ; + int arg1 ; + long long *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = (int)jarg1; + result = (long long *)new_long_long_array(arg1); + *(long long **)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_delete_1long_1long_1array(JNIEnv *jenv, jclass jcls, jlong jarg1) { + long long *arg1 = (long long *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(long long **)&jarg1; + delete_long_long_array(arg1); +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_long_1long_1array_1getitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) { + jlong jresult = 0 ; + long long *arg1 = (long long *) 0 ; + int arg2 ; + long long result; + + (void)jenv; + (void)jcls; + arg1 = *(long long **)&jarg1; + arg2 = (int)jarg2; + result = (long long)long_long_array_getitem(arg1,arg2); + jresult = (jlong)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_long_1long_1array_1setitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2, jlong jarg3) { + long long *arg1 = (long long *) 0 ; + int arg2 ; + long long arg3 ; + + (void)jenv; + (void)jcls; + arg1 = *(long long **)&jarg1; + arg2 = (int)jarg2; + arg3 = (long long)jarg3; + long_long_array_setitem(arg1,arg2,arg3); +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_new_1unsigned_1int_1array(JNIEnv *jenv, jclass jcls, jint jarg1) { + jlong jresult = 0 ; + int arg1 ; + unsigned int *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = (int)jarg1; + result = (unsigned int *)new_unsigned_int_array(arg1); + *(unsigned int **)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_delete_1unsigned_1int_1array(JNIEnv *jenv, jclass jcls, jlong jarg1) { + unsigned int *arg1 = (unsigned int *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(unsigned int **)&jarg1; + delete_unsigned_int_array(arg1); +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_unsigned_1int_1array_1getitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) { + jlong jresult = 0 ; + unsigned int *arg1 = (unsigned int *) 0 ; + int arg2 ; + unsigned int result; + + (void)jenv; + (void)jcls; + arg1 = *(unsigned int **)&jarg1; + arg2 = (int)jarg2; + result = (unsigned int)unsigned_int_array_getitem(arg1,arg2); + jresult = (jlong)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_unsigned_1int_1array_1setitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2, jlong jarg3) { + unsigned int *arg1 = (unsigned int *) 0 ; + int arg2 ; + unsigned int arg3 ; + + (void)jenv; + (void)jcls; + arg1 = *(unsigned int **)&jarg1; + arg2 = (int)jarg2; + arg3 = (unsigned int)jarg3; + unsigned_int_array_setitem(arg1,arg2,arg3); +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_new_1SCIP_1BoundType_1array(JNIEnv *jenv, jclass jcls, jint jarg1) { + jlong jresult = 0 ; + int arg1 ; + SCIP_BOUNDTYPE *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = (int)jarg1; + result = (SCIP_BOUNDTYPE *)new_SCIP_BoundType_array(arg1); + *(SCIP_BOUNDTYPE **)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_delete_1SCIP_1BoundType_1array(JNIEnv *jenv, jclass jcls, jlong jarg1) { + SCIP_BOUNDTYPE *arg1 = (SCIP_BOUNDTYPE *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP_BOUNDTYPE **)&jarg1; + delete_SCIP_BoundType_array(arg1); +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1BoundType_1array_1getitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) { + jint jresult = 0 ; + SCIP_BOUNDTYPE *arg1 = (SCIP_BOUNDTYPE *) 0 ; + int arg2 ; + SCIP_BOUNDTYPE result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP_BOUNDTYPE **)&jarg1; + arg2 = (int)jarg2; + result = (SCIP_BOUNDTYPE)SCIP_BoundType_array_getitem(arg1,arg2); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIP_1BoundType_1array_1setitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2, jint jarg3) { + SCIP_BOUNDTYPE *arg1 = (SCIP_BOUNDTYPE *) 0 ; + int arg2 ; + SCIP_BOUNDTYPE arg3 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP_BOUNDTYPE **)&jarg1; + arg2 = (int)jarg2; + arg3 = (SCIP_BOUNDTYPE)jarg3; + SCIP_BoundType_array_setitem(arg1,arg2,arg3); +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_new_1String_1array(JNIEnv *jenv, jclass jcls, jint jarg1) { + jlong jresult = 0 ; + int arg1 ; + char **result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = (int)jarg1; + result = (char **)new_String_array(arg1); + *(char ***)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_delete_1String_1array(JNIEnv *jenv, jclass jcls, jlong jarg1) { + char **arg1 = (char **) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(char ***)&jarg1; + delete_String_array(arg1); +} + + +SWIGEXPORT jstring JNICALL Java_jscip_SCIPJNIJNI_String_1array_1getitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) { + jstring jresult = 0 ; + char **arg1 = (char **) 0 ; + int arg2 ; + char *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(char ***)&jarg1; + arg2 = (int)jarg2; + result = (char *)String_array_getitem(arg1,arg2); + if (result) jresult = jenv->NewStringUTF((const char *)result); + return jresult; +} + + +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_String_1array_1setitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2, jstring jarg3) { + char **arg1 = (char **) 0 ; + int arg2 ; + char *arg3 = (char *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(char ***)&jarg1; + arg2 = (int)jarg2; + arg3 = 0; + if (jarg3) { + arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0); + if (!arg3) return ; + } + String_array_setitem(arg1,arg2,arg3); + if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3); +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_new_1SCIP_1VAR_1array(JNIEnv *jenv, jclass jcls, jint jarg1) { + jlong jresult = 0 ; + int arg1 ; + SCIP_VAR **result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = (int)jarg1; + result = (SCIP_VAR **)new_SCIP_VAR_array(arg1); + *(SCIP_VAR ***)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_delete_1SCIP_1VAR_1array(JNIEnv *jenv, jclass jcls, jlong jarg1) { + SCIP_VAR **arg1 = (SCIP_VAR **) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP_VAR ***)&jarg1; + delete_SCIP_VAR_array(arg1); +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIP_1VAR_1array_1getitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) { + jlong jresult = 0 ; + SCIP_VAR **arg1 = (SCIP_VAR **) 0 ; + int arg2 ; + SCIP_VAR *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP_VAR ***)&jarg1; + arg2 = (int)jarg2; + result = (SCIP_VAR *)SCIP_VAR_array_getitem(arg1,arg2); + *(SCIP_VAR **)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIP_1VAR_1array_1setitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2, jlong jarg3) { + SCIP_VAR **arg1 = (SCIP_VAR **) 0 ; + int arg2 ; + SCIP_VAR *arg3 = (SCIP_VAR *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP_VAR ***)&jarg1; + arg2 = (int)jarg2; + arg3 = *(SCIP_VAR **)&jarg3; + SCIP_VAR_array_setitem(arg1,arg2,arg3); +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_new_1SCIP_1EXPR_1array(JNIEnv *jenv, jclass jcls, jint jarg1) { + jlong jresult = 0 ; + int arg1 ; + SCIP_EXPR **result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = (int)jarg1; + result = (SCIP_EXPR **)new_SCIP_EXPR_array(arg1); + *(SCIP_EXPR ***)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_delete_1SCIP_1EXPR_1array(JNIEnv *jenv, jclass jcls, jlong jarg1) { + SCIP_EXPR **arg1 = (SCIP_EXPR **) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP_EXPR ***)&jarg1; + delete_SCIP_EXPR_array(arg1); +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EXPR_1array_1getitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) { + jlong jresult = 0 ; + SCIP_EXPR **arg1 = (SCIP_EXPR **) 0 ; + int arg2 ; + SCIP_EXPR *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP_EXPR ***)&jarg1; + arg2 = (int)jarg2; + result = (SCIP_EXPR *)SCIP_EXPR_array_getitem(arg1,arg2); + *(SCIP_EXPR **)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EXPR_1array_1setitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2, jlong jarg3) { + SCIP_EXPR **arg1 = (SCIP_EXPR **) 0 ; + int arg2 ; + SCIP_EXPR *arg3 = (SCIP_EXPR *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP_EXPR ***)&jarg1; + arg2 = (int)jarg2; + arg3 = *(SCIP_EXPR **)&jarg3; + SCIP_EXPR_array_setitem(arg1,arg2,arg3); +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_new_1SCIP_1CONS_1array(JNIEnv *jenv, jclass jcls, jint jarg1) { + jlong jresult = 0 ; + int arg1 ; + SCIP_CONS **result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = (int)jarg1; + result = (SCIP_CONS **)new_SCIP_CONS_array(arg1); + *(SCIP_CONS ***)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_delete_1SCIP_1CONS_1array(JNIEnv *jenv, jclass jcls, jlong jarg1) { + SCIP_CONS **arg1 = (SCIP_CONS **) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP_CONS ***)&jarg1; + delete_SCIP_CONS_array(arg1); +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIP_1CONS_1array_1getitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) { + jlong jresult = 0 ; + SCIP_CONS **arg1 = (SCIP_CONS **) 0 ; + int arg2 ; + SCIP_CONS *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP_CONS ***)&jarg1; + arg2 = (int)jarg2; + result = (SCIP_CONS *)SCIP_CONS_array_getitem(arg1,arg2); + *(SCIP_CONS **)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIP_1CONS_1array_1setitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2, jlong jarg3) { + SCIP_CONS **arg1 = (SCIP_CONS **) 0 ; + int arg2 ; + SCIP_CONS *arg3 = (SCIP_CONS *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP_CONS ***)&jarg1; + arg2 = (int)jarg2; + arg3 = *(SCIP_CONS **)&jarg3; + SCIP_CONS_array_setitem(arg1,arg2,arg3); +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_new_1SCIP_1SOL_1array(JNIEnv *jenv, jclass jcls, jint jarg1) { + jlong jresult = 0 ; + int arg1 ; + SCIP_SOL **result = 0 ; + + (void)jenv; + (void)jcls; arg1 = (int)jarg1; - result = (int *)new_int_array(arg1); - *(int **)&jresult = result; + result = (SCIP_SOL **)new_SCIP_SOL_array(arg1); + *(SCIP_SOL ***)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_delete_1SCIP_1SOL_1array(JNIEnv *jenv, jclass jcls, jlong jarg1) { + SCIP_SOL **arg1 = (SCIP_SOL **) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP_SOL ***)&jarg1; + delete_SCIP_SOL_array(arg1); +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIP_1SOL_1array_1getitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) { + jlong jresult = 0 ; + SCIP_SOL **arg1 = (SCIP_SOL **) 0 ; + int arg2 ; + SCIP_SOL *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP_SOL ***)&jarg1; + arg2 = (int)jarg2; + result = (SCIP_SOL *)SCIP_SOL_array_getitem(arg1,arg2); + *(SCIP_SOL **)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIP_1SOL_1array_1setitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2, jlong jarg3) { + SCIP_SOL **arg1 = (SCIP_SOL **) 0 ; + int arg2 ; + SCIP_SOL *arg3 = (SCIP_SOL *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP_SOL ***)&jarg1; + arg2 = (int)jarg2; + arg3 = *(SCIP_SOL **)&jarg3; + SCIP_SOL_array_setitem(arg1,arg2,arg3); +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_new_1SCIP_1VAR_1array_1array(JNIEnv *jenv, jclass jcls, jint jarg1) { + jlong jresult = 0 ; + int arg1 ; + SCIP_VAR ***result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = (int)jarg1; + result = (SCIP_VAR ***)new_SCIP_VAR_array_array(arg1); + *(SCIP_VAR ****)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_delete_1SCIP_1VAR_1array_1array(JNIEnv *jenv, jclass jcls, jlong jarg1) { + SCIP_VAR ***arg1 = (SCIP_VAR ***) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP_VAR ****)&jarg1; + delete_SCIP_VAR_array_array(arg1); +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIP_1VAR_1array_1array_1getitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) { + jlong jresult = 0 ; + SCIP_VAR ***arg1 = (SCIP_VAR ***) 0 ; + int arg2 ; + SCIP_VAR **result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP_VAR ****)&jarg1; + arg2 = (int)jarg2; + result = (SCIP_VAR **)SCIP_VAR_array_array_getitem(arg1,arg2); + *(SCIP_VAR ***)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIP_1VAR_1array_1array_1setitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2, jlong jarg3) { + SCIP_VAR ***arg1 = (SCIP_VAR ***) 0 ; + int arg2 ; + SCIP_VAR **arg3 = (SCIP_VAR **) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP_VAR ****)&jarg1; + arg2 = (int)jarg2; + arg3 = *(SCIP_VAR ***)&jarg3; + SCIP_VAR_array_array_setitem(arg1,arg2,arg3); +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1OKAY_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Retcode result; + + (void)jenv; + (void)jcls; + result = (SCIP_Retcode)SCIP_OKAY; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1ERROR_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Retcode result; + + (void)jenv; + (void)jcls; + result = (SCIP_Retcode)SCIP_ERROR; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1NOMEMORY_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Retcode result; + + (void)jenv; + (void)jcls; + result = (SCIP_Retcode)SCIP_NOMEMORY; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1READERROR_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Retcode result; + + (void)jenv; + (void)jcls; + result = (SCIP_Retcode)SCIP_READERROR; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1WRITEERROR_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Retcode result; + + (void)jenv; + (void)jcls; + result = (SCIP_Retcode)SCIP_WRITEERROR; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1NOFILE_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Retcode result; + + (void)jenv; + (void)jcls; + result = (SCIP_Retcode)SCIP_NOFILE; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1FILECREATEERROR_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Retcode result; + + (void)jenv; + (void)jcls; + result = (SCIP_Retcode)SCIP_FILECREATEERROR; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1LPERROR_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Retcode result; + + (void)jenv; + (void)jcls; + result = (SCIP_Retcode)SCIP_LPERROR; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1NOPROBLEM_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Retcode result; + + (void)jenv; + (void)jcls; + result = (SCIP_Retcode)SCIP_NOPROBLEM; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1INVALIDCALL_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Retcode result; + + (void)jenv; + (void)jcls; + result = (SCIP_Retcode)SCIP_INVALIDCALL; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1INVALIDDATA_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Retcode result; + + (void)jenv; + (void)jcls; + result = (SCIP_Retcode)SCIP_INVALIDDATA; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1INVALIDRESULT_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Retcode result; + + (void)jenv; + (void)jcls; + result = (SCIP_Retcode)SCIP_INVALIDRESULT; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1PLUGINNOTFOUND_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Retcode result; + + (void)jenv; + (void)jcls; + result = (SCIP_Retcode)SCIP_PLUGINNOTFOUND; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1PARAMETERUNKNOWN_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Retcode result; + + (void)jenv; + (void)jcls; + result = (SCIP_Retcode)SCIP_PARAMETERUNKNOWN; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1PARAMETERWRONGTYPE_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Retcode result; + + (void)jenv; + (void)jcls; + result = (SCIP_Retcode)SCIP_PARAMETERWRONGTYPE; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1PARAMETERWRONGVAL_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Retcode result; + + (void)jenv; + (void)jcls; + result = (SCIP_Retcode)SCIP_PARAMETERWRONGVAL; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1KEYALREADYEXISTING_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Retcode result; + + (void)jenv; + (void)jcls; + result = (SCIP_Retcode)SCIP_KEYALREADYEXISTING; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1MAXDEPTHLEVEL_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Retcode result; + + (void)jenv; + (void)jcls; + result = (SCIP_Retcode)SCIP_MAXDEPTHLEVEL; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1BRANCHERROR_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Retcode result; + + (void)jenv; + (void)jcls; + result = (SCIP_Retcode)SCIP_BRANCHERROR; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1VARTYPE_1BINARY_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Vartype result; + + (void)jenv; + (void)jcls; + result = (SCIP_Vartype)SCIP_VARTYPE_BINARY; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1VARTYPE_1INTEGER_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Vartype result; + + (void)jenv; + (void)jcls; + result = (SCIP_Vartype)SCIP_VARTYPE_INTEGER; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1VARTYPE_1IMPLINT_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Vartype result; + + (void)jenv; + (void)jcls; + result = (SCIP_Vartype)SCIP_VARTYPE_IMPLINT; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1VARTYPE_1CONTINUOUS_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Vartype result; + + (void)jenv; + (void)jcls; + result = (SCIP_Vartype)SCIP_VARTYPE_CONTINUOUS; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1BOUNDTYPE_1LOWER_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_BoundType result; + + (void)jenv; + (void)jcls; + result = (SCIP_BoundType)SCIP_BOUNDTYPE_LOWER; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1BOUNDTYPE_1UPPER_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_BoundType result; + + (void)jenv; + (void)jcls; + result = (SCIP_BoundType)SCIP_BOUNDTYPE_UPPER; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1ORBITOPETYPE_1FULL_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_OrbitopeType result; + + (void)jenv; + (void)jcls; + result = (SCIP_OrbitopeType)SCIP_ORBITOPETYPE_FULL; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1ORBITOPETYPE_1PARTITIONING_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_OrbitopeType result; + + (void)jenv; + (void)jcls; + result = (SCIP_OrbitopeType)SCIP_ORBITOPETYPE_PARTITIONING; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1ORBITOPETYPE_1PACKING_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_OrbitopeType result; + + (void)jenv; + (void)jcls; + result = (SCIP_OrbitopeType)SCIP_ORBITOPETYPE_PACKING; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1PARAMSETTING_1DEFAULT_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_ParamSetting result; + + (void)jenv; + (void)jcls; + result = (SCIP_ParamSetting)SCIP_PARAMSETTING_DEFAULT; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1PARAMSETTING_1AGGRESSIVE_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_ParamSetting result; + + (void)jenv; + (void)jcls; + result = (SCIP_ParamSetting)SCIP_PARAMSETTING_AGGRESSIVE; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1PARAMSETTING_1FAST_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_ParamSetting result; + + (void)jenv; + (void)jcls; + result = (SCIP_ParamSetting)SCIP_PARAMSETTING_FAST; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1PARAMSETTING_1OFF_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_ParamSetting result; + + (void)jenv; + (void)jcls; + result = (SCIP_ParamSetting)SCIP_PARAMSETTING_OFF; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1PARAMEMPHASIS_1DEFAULT_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_ParamEmphasis result; + + (void)jenv; + (void)jcls; + result = (SCIP_ParamEmphasis)SCIP_PARAMEMPHASIS_DEFAULT; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1PARAMEMPHASIS_1CPSOLVER_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_ParamEmphasis result; + + (void)jenv; + (void)jcls; + result = (SCIP_ParamEmphasis)SCIP_PARAMEMPHASIS_CPSOLVER; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1PARAMEMPHASIS_1EASYCIP_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_ParamEmphasis result; + + (void)jenv; + (void)jcls; + result = (SCIP_ParamEmphasis)SCIP_PARAMEMPHASIS_EASYCIP; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1PARAMEMPHASIS_1FEASIBILITY_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_ParamEmphasis result; + + (void)jenv; + (void)jcls; + result = (SCIP_ParamEmphasis)SCIP_PARAMEMPHASIS_FEASIBILITY; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1PARAMEMPHASIS_1HARDLP_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_ParamEmphasis result; + + (void)jenv; + (void)jcls; + result = (SCIP_ParamEmphasis)SCIP_PARAMEMPHASIS_HARDLP; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1PARAMEMPHASIS_1OPTIMALITY_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_ParamEmphasis result; + + (void)jenv; + (void)jcls; + result = (SCIP_ParamEmphasis)SCIP_PARAMEMPHASIS_OPTIMALITY; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1PARAMEMPHASIS_1COUNTER_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_ParamEmphasis result; + + (void)jenv; + (void)jcls; + result = (SCIP_ParamEmphasis)SCIP_PARAMEMPHASIS_COUNTER; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1PARAMEMPHASIS_1PHASEFEAS_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_ParamEmphasis result; + + (void)jenv; + (void)jcls; + result = (SCIP_ParamEmphasis)SCIP_PARAMEMPHASIS_PHASEFEAS; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1PARAMEMPHASIS_1PHASEIMPROVE_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_ParamEmphasis result; + + (void)jenv; + (void)jcls; + result = (SCIP_ParamEmphasis)SCIP_PARAMEMPHASIS_PHASEIMPROVE; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1PARAMEMPHASIS_1PHASEPROOF_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_ParamEmphasis result; + + (void)jenv; + (void)jcls; + result = (SCIP_ParamEmphasis)SCIP_PARAMEMPHASIS_PHASEPROOF; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1VERBLEVEL_1NONE_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_VerbLevel result; + + (void)jenv; + (void)jcls; + result = (SCIP_VerbLevel)SCIP_VERBLEVEL_NONE; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1VERBLEVEL_1DIALOG_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_VerbLevel result; + + (void)jenv; + (void)jcls; + result = (SCIP_VerbLevel)SCIP_VERBLEVEL_DIALOG; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1VERBLEVEL_1MINIMAL_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_VerbLevel result; + + (void)jenv; + (void)jcls; + result = (SCIP_VerbLevel)SCIP_VERBLEVEL_MINIMAL; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1VERBLEVEL_1NORMAL_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_VerbLevel result; + + (void)jenv; + (void)jcls; + result = (SCIP_VerbLevel)SCIP_VERBLEVEL_NORMAL; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1VERBLEVEL_1HIGH_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_VerbLevel result; + + (void)jenv; + (void)jcls; + result = (SCIP_VerbLevel)SCIP_VERBLEVEL_HIGH; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1VERBLEVEL_1FULL_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_VerbLevel result; + + (void)jenv; + (void)jcls; + result = (SCIP_VerbLevel)SCIP_VERBLEVEL_FULL; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1OBJSENSE_1MAXIMIZE_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Objsense result; + + (void)jenv; + (void)jcls; + result = (SCIP_Objsense)SCIP_OBJSENSE_MAXIMIZE; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1OBJSENSE_1MINIMIZE_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Objsense result; + + (void)jenv; + (void)jcls; + result = (SCIP_Objsense)SCIP_OBJSENSE_MINIMIZE; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STATUS_1UNKNOWN_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Status result; + + (void)jenv; + (void)jcls; + result = (SCIP_Status)SCIP_STATUS_UNKNOWN; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STATUS_1USERINTERRUPT_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Status result; + + (void)jenv; + (void)jcls; + result = (SCIP_Status)SCIP_STATUS_USERINTERRUPT; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STATUS_1NODELIMIT_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Status result; + + (void)jenv; + (void)jcls; + result = (SCIP_Status)SCIP_STATUS_NODELIMIT; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STATUS_1TOTALNODELIMIT_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Status result; + + (void)jenv; + (void)jcls; + result = (SCIP_Status)SCIP_STATUS_TOTALNODELIMIT; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STATUS_1STALLNODELIMIT_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Status result; + + (void)jenv; + (void)jcls; + result = (SCIP_Status)SCIP_STATUS_STALLNODELIMIT; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STATUS_1TIMELIMIT_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Status result; + + (void)jenv; + (void)jcls; + result = (SCIP_Status)SCIP_STATUS_TIMELIMIT; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STATUS_1MEMLIMIT_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Status result; + + (void)jenv; + (void)jcls; + result = (SCIP_Status)SCIP_STATUS_MEMLIMIT; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STATUS_1GAPLIMIT_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Status result; + + (void)jenv; + (void)jcls; + result = (SCIP_Status)SCIP_STATUS_GAPLIMIT; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STATUS_1SOLLIMIT_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Status result; + + (void)jenv; + (void)jcls; + result = (SCIP_Status)SCIP_STATUS_SOLLIMIT; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STATUS_1BESTSOLLIMIT_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Status result; + + (void)jenv; + (void)jcls; + result = (SCIP_Status)SCIP_STATUS_BESTSOLLIMIT; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STATUS_1RESTARTLIMIT_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Status result; + + (void)jenv; + (void)jcls; + result = (SCIP_Status)SCIP_STATUS_RESTARTLIMIT; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STATUS_1OPTIMAL_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Status result; + + (void)jenv; + (void)jcls; + result = (SCIP_Status)SCIP_STATUS_OPTIMAL; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STATUS_1INFEASIBLE_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Status result; + + (void)jenv; + (void)jcls; + result = (SCIP_Status)SCIP_STATUS_INFEASIBLE; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STATUS_1UNBOUNDED_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Status result; + + (void)jenv; + (void)jcls; + result = (SCIP_Status)SCIP_STATUS_UNBOUNDED; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STATUS_1INFORUNBD_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Status result; + + (void)jenv; + (void)jcls; + result = (SCIP_Status)SCIP_STATUS_INFORUNBD; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STATUS_1TERMINATE_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Status result; + + (void)jenv; + (void)jcls; + result = (SCIP_Status)SCIP_STATUS_TERMINATE; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STAGE_1INIT_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Stage result; + + (void)jenv; + (void)jcls; + result = (SCIP_Stage)SCIP_STAGE_INIT; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STAGE_1PROBLEM_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Stage result; + + (void)jenv; + (void)jcls; + result = (SCIP_Stage)SCIP_STAGE_PROBLEM; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STAGE_1TRANSFORMING_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Stage result; + + (void)jenv; + (void)jcls; + result = (SCIP_Stage)SCIP_STAGE_TRANSFORMING; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STAGE_1TRANSFORMED_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Stage result; + + (void)jenv; + (void)jcls; + result = (SCIP_Stage)SCIP_STAGE_TRANSFORMED; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STAGE_1INITPRESOLVE_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Stage result; + + (void)jenv; + (void)jcls; + result = (SCIP_Stage)SCIP_STAGE_INITPRESOLVE; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STAGE_1PRESOLVING_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Stage result; + + (void)jenv; + (void)jcls; + result = (SCIP_Stage)SCIP_STAGE_PRESOLVING; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STAGE_1EXITPRESOLVE_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Stage result; + + (void)jenv; + (void)jcls; + result = (SCIP_Stage)SCIP_STAGE_EXITPRESOLVE; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STAGE_1PRESOLVED_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Stage result; + + (void)jenv; + (void)jcls; + result = (SCIP_Stage)SCIP_STAGE_PRESOLVED; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STAGE_1INITSOLVE_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Stage result; + + (void)jenv; + (void)jcls; + result = (SCIP_Stage)SCIP_STAGE_INITSOLVE; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STAGE_1SOLVING_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Stage result; + + (void)jenv; + (void)jcls; + result = (SCIP_Stage)SCIP_STAGE_SOLVING; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STAGE_1SOLVED_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Stage result; + + (void)jenv; + (void)jcls; + result = (SCIP_Stage)SCIP_STAGE_SOLVED; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STAGE_1EXITSOLVE_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Stage result; + + (void)jenv; + (void)jcls; + result = (SCIP_Stage)SCIP_STAGE_EXITSOLVE; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STAGE_1FREETRANS_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Stage result; + + (void)jenv; + (void)jcls; + result = (SCIP_Stage)SCIP_STAGE_FREETRANS; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STAGE_1FREE_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Stage result; + + (void)jenv; + (void)jcls; + result = (SCIP_Stage)SCIP_STAGE_FREE; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIPcalcMachineEpsilon(JNIEnv *jenv, jclass jcls) { + jdouble jresult = 0 ; + double result; + + (void)jenv; + (void)jcls; + result = (double)SCIPcalcMachineEpsilon(); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPcreate(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jint jresult = 0 ; + SCIP **arg1 = (SCIP **) 0 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP ***)&jarg1; + result = (SCIP_RETCODE)SCIPcreate(arg1); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPreadProb(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jstring jarg3) { + jint jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = 0; + if (jarg3) { + arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0); + if (!arg3) return 0; + } + result = (SCIP_RETCODE)SCIPreadProb(arg1,(char const *)arg2,(char const *)arg3); + jresult = (jint)result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3); + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPreadParams(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2) { + jint jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + result = (SCIP_RETCODE)SCIPreadParams(arg1,(char const *)arg2); + jresult = (jint)result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPcreateProbBasic(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2) { + jint jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + result = (SCIP_RETCODE)SCIPcreateProbBasic(arg1,(char const *)arg2); + jresult = (jint)result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPincludeDefaultPlugins(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jint jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + result = (SCIP_RETCODE)SCIPincludeDefaultPlugins(arg1); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPsolve(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jint jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + result = (SCIP_RETCODE)SCIPsolve(arg1); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPsolveConcurrent(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jint jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + result = (SCIP_RETCODE)SCIPsolveConcurrent(arg1); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPinterruptSolve(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jint jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + result = (SCIP_RETCODE)SCIPinterruptSolve(arg1); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIPisSolveInterrupted(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jlong jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + unsigned int result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + result = (unsigned int)SCIPisSolveInterrupted(arg1); + jresult = (jlong)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPaddVar(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jint jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + SCIP_VAR *arg2 = (SCIP_VAR *) 0 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = *(SCIP_VAR **)&jarg2; + result = (SCIP_RETCODE)SCIPaddVar(arg1,arg2); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPgetNVars(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jint jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + int result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + result = (int)SCIPgetNVars(arg1); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIPgetVars(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jlong jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + SCIP_VAR **result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + result = (SCIP_VAR **)SCIPgetVars(arg1); + *(SCIP_VAR ***)&jresult = result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPgetNOrigVars(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jint jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + int result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + result = (int)SCIPgetNOrigVars(arg1); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIPgetOrigVars(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jlong jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + SCIP_VAR **result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + result = (SCIP_VAR **)SCIPgetOrigVars(arg1); + *(SCIP_VAR ***)&jresult = result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPaddCons(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jint jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + SCIP_CONS *arg2 = (SCIP_CONS *) 0 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = *(SCIP_CONS **)&jarg2; + result = (SCIP_RETCODE)SCIPaddCons(arg1,arg2); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPwriteOrigProblem(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jstring jarg3, jlong jarg4) { + jint jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + unsigned int arg4 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = 0; + if (jarg3) { + arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0); + if (!arg3) return 0; + } + arg4 = (unsigned int)jarg4; + result = (SCIP_RETCODE)SCIPwriteOrigProblem(arg1,(char const *)arg2,(char const *)arg3,arg4); + jresult = (jint)result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3); + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPwriteTransProblem(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jstring jarg3, jlong jarg4) { + jint jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + unsigned int arg4 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = 0; + if (jarg3) { + arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0); + if (!arg3) return 0; + } + arg4 = (unsigned int)jarg4; + result = (SCIP_RETCODE)SCIPwriteTransProblem(arg1,(char const *)arg2,(char const *)arg3,arg4); + jresult = (jint)result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3); + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPprintStatistics(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jint jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + FILE *arg2 = (FILE *) 0 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = *(FILE **)&jarg2; + result = (SCIP_RETCODE)SCIPprintStatistics(arg1,arg2); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPprintBestSol(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jint jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + FILE *arg2 = (FILE *) 0 ; + unsigned int arg3 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = *(FILE **)&jarg2; + arg3 = (unsigned int)jarg3; + result = (SCIP_RETCODE)SCIPprintBestSol(arg1,arg2,arg3); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIPsetMessagehdlrQuiet(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + SCIP *arg1 = (SCIP *) 0 ; + unsigned int arg2 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = (unsigned int)jarg2; + SCIPsetMessagehdlrQuiet(arg1,arg2); +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPgetStatus(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jint jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + SCIP_STATUS result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + result = (SCIP_STATUS)SCIPgetStatus(arg1); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPgetStage(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jint jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + SCIP_STAGE result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + result = (SCIP_STAGE)SCIPgetStage(arg1); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIPgetSols(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jlong jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + SCIP_SOL **result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + result = (SCIP_SOL **)SCIPgetSols(arg1); + *(SCIP_SOL ***)&jresult = result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPgetNSols(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jint jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + int result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + result = (int)SCIPgetNSols(arg1); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIPgetBestSol(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jlong jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + SCIP_SOL *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + result = (SCIP_SOL *)SCIPgetBestSol(arg1); + *(SCIP_SOL **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIPgetSolVal(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jdouble jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + SCIP_SOL *arg2 = (SCIP_SOL *) 0 ; + SCIP_VAR *arg3 = (SCIP_VAR *) 0 ; + double result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = *(SCIP_SOL **)&jarg2; + arg3 = *(SCIP_VAR **)&jarg3; + result = (double)SCIPgetSolVal(arg1,arg2,arg3); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIPgetSolOrigObj(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jdouble jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + SCIP_SOL *arg2 = (SCIP_SOL *) 0 ; + double result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = *(SCIP_SOL **)&jarg2; + result = (double)SCIPgetSolOrigObj(arg1,arg2); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIPinfinity(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jdouble jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + double result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + result = (double)SCIPinfinity(arg1); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIPepsilon(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jdouble jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + double result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + result = (double)SCIPepsilon(arg1); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIPfeastol(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jdouble jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + double result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + result = (double)SCIPfeastol(arg1); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPgetBoolParam(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3) { + jint jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + unsigned int *arg3 = (unsigned int *) 0 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = *(unsigned int **)&jarg3; + result = (SCIP_RETCODE)SCIPgetBoolParam(arg1,(char const *)arg2,arg3); + jresult = (jint)result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPgetIntParam(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3) { + jint jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + int *arg3 = (int *) 0 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = *(int **)&jarg3; + result = (SCIP_RETCODE)SCIPgetIntParam(arg1,(char const *)arg2,arg3); + jresult = (jint)result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPgetLongintParam(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3) { + jint jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + long long *arg3 = (long long *) 0 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = *(long long **)&jarg3; + result = (SCIP_RETCODE)SCIPgetLongintParam(arg1,(char const *)arg2,arg3); + jresult = (jint)result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPgetRealParam(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3) { + jint jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + double *arg3 = (double *) 0 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = *(double **)&jarg3; + result = (SCIP_RETCODE)SCIPgetRealParam(arg1,(char const *)arg2,arg3); + jresult = (jint)result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPgetCharParam(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3) { + jint jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = *(char **)&jarg3; + result = (SCIP_RETCODE)SCIPgetCharParam(arg1,(char const *)arg2,arg3); + jresult = (jint)result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPgetStringParam(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3) { + jint jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + char **arg3 = (char **) 0 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = *(char ***)&jarg3; + result = (SCIP_RETCODE)SCIPgetStringParam(arg1,(char const *)arg2,arg3); + jresult = (jint)result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPsetBoolParam(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3) { + jint jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + unsigned int arg3 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = (unsigned int)jarg3; + result = (SCIP_RETCODE)SCIPsetBoolParam(arg1,(char const *)arg2,arg3); + jresult = (jint)result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPsetIntParam(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jint jarg3) { + jint jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = (int)jarg3; + result = (SCIP_RETCODE)SCIPsetIntParam(arg1,(char const *)arg2,arg3); + jresult = (jint)result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPsetLongintParam(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3) { + jint jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + long long arg3 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = (long long)jarg3; + result = (SCIP_RETCODE)SCIPsetLongintParam(arg1,(char const *)arg2,arg3); + jresult = (jint)result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPsetRealParam(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jdouble jarg3) { + jint jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + double arg3 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = (double)jarg3; + result = (SCIP_RETCODE)SCIPsetRealParam(arg1,(char const *)arg2,arg3); + jresult = (jint)result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPsetCharParam(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jchar jarg3) { + jint jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + char arg3 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = (char)jarg3; + result = (SCIP_RETCODE)SCIPsetCharParam(arg1,(char const *)arg2,arg3); + jresult = (jint)result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPsetStringParam(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jstring jarg3) { + jint jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = 0; + if (jarg3) { + arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0); + if (!arg3) return 0; + } + result = (SCIP_RETCODE)SCIPsetStringParam(arg1,(char const *)arg2,(char const *)arg3); + jresult = (jint)result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3); + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPsetPresolving(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2, jlong jarg3) { + jint jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + SCIP_PARAMSETTING arg2 ; + unsigned int arg3 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = (SCIP_PARAMSETTING)jarg2; + arg3 = (unsigned int)jarg3; + result = (SCIP_RETCODE)SCIPsetPresolving(arg1,arg2,arg3); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPsetHeuristics(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2, jlong jarg3) { + jint jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + SCIP_PARAMSETTING arg2 ; + unsigned int arg3 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = (SCIP_PARAMSETTING)jarg2; + arg3 = (unsigned int)jarg3; + result = (SCIP_RETCODE)SCIPsetHeuristics(arg1,arg2,arg3); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPsetEmphasis(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2, jlong jarg3) { + jint jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + SCIP_PARAMEMPHASIS arg2 ; + unsigned int arg3 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = (SCIP_PARAMEMPHASIS)jarg2; + arg3 = (unsigned int)jarg3; + result = (SCIP_RETCODE)SCIPsetEmphasis(arg1,arg2,arg3); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPsetObjsense(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) { + jint jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + SCIP_OBJSENSE arg2 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = (SCIP_OBJSENSE)jarg2; + result = (SCIP_RETCODE)SCIPsetObjsense(arg1,arg2); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPgetObjsense(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jint jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + SCIP_OBJSENSE result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + result = (SCIP_OBJSENSE)SCIPgetObjsense(arg1); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIPgetGap(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jdouble jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + double result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + result = (double)SCIPgetGap(arg1); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPchgVarObj(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jdouble jarg3) { + jint jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + SCIP_VAR *arg2 = (SCIP_VAR *) 0 ; + double arg3 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = *(SCIP_VAR **)&jarg2; + arg3 = (double)jarg3; + result = (SCIP_RETCODE)SCIPchgVarObj(arg1,arg2,arg3); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPchgVarBranchPriority(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jint jarg3) { + jint jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + SCIP_VAR *arg2 = (SCIP_VAR *) 0 ; + int arg3 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = *(SCIP_VAR **)&jarg2; + arg3 = (int)jarg3; + result = (SCIP_RETCODE)SCIPchgVarBranchPriority(arg1,arg2,arg3); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPcreateSol(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jint jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + SCIP_SOL **arg2 = (SCIP_SOL **) 0 ; + SCIP_HEUR *arg3 = (SCIP_HEUR *) 0 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = *(SCIP_SOL ***)&jarg2; + arg3 = *(SCIP_HEUR **)&jarg3; + result = (SCIP_RETCODE)SCIPcreateSol(arg1,arg2,arg3); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPcreatePartialSol(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jint jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + SCIP_SOL **arg2 = (SCIP_SOL **) 0 ; + SCIP_HEUR *arg3 = (SCIP_HEUR *) 0 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = *(SCIP_SOL ***)&jarg2; + arg3 = *(SCIP_HEUR **)&jarg3; + result = (SCIP_RETCODE)SCIPcreatePartialSol(arg1,arg2,arg3); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPsetSolVal(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3, jdouble jarg4) { + jint jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + SCIP_SOL *arg2 = (SCIP_SOL *) 0 ; + SCIP_VAR *arg3 = (SCIP_VAR *) 0 ; + double arg4 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = *(SCIP_SOL **)&jarg2; + arg3 = *(SCIP_VAR **)&jarg3; + arg4 = (double)jarg4; + result = (SCIP_RETCODE)SCIPsetSolVal(arg1,arg2,arg3,arg4); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPsetSolVals(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jint jarg3, jlong jarg4, jlong jarg5) { + jint jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + SCIP_SOL *arg2 = (SCIP_SOL *) 0 ; + int arg3 ; + SCIP_VAR **arg4 = (SCIP_VAR **) 0 ; + double *arg5 = (double *) 0 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = *(SCIP_SOL **)&jarg2; + arg3 = (int)jarg3; + arg4 = *(SCIP_VAR ***)&jarg4; + arg5 = *(double **)&jarg5; + result = (SCIP_RETCODE)SCIPsetSolVals(arg1,arg2,arg3,arg4,arg5); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPaddSolFree(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jint jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + SCIP_SOL **arg2 = (SCIP_SOL **) 0 ; + unsigned int *arg3 = (unsigned int *) 0 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = *(SCIP_SOL ***)&jarg2; + arg3 = *(unsigned int **)&jarg3; + result = (SCIP_RETCODE)SCIPaddSolFree(arg1,arg2,arg3); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIPgetPrimalbound(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jdouble jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + double result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + result = (double)SCIPgetPrimalbound(arg1); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIPgetDualbound(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jdouble jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + double result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + result = (double)SCIPgetDualbound(arg1); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIPgetSolvingTime(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jdouble jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + double result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + result = (double)SCIPgetSolvingTime(arg1); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_BMScheckEmptyMemory(JNIEnv *jenv, jclass jcls) { + (void)jenv; + (void)jcls; + BMScheckEmptyMemory(); +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_BMSgetMemoryUsed(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + long long result; + + (void)jenv; + (void)jcls; + result = (long long)BMSgetMemoryUsed(); + jresult = (jlong)result; + return jresult; +} + + +SWIGEXPORT jstring JNICALL Java_jscip_SCIPJNIJNI_SCIPvarGetName(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jstring jresult = 0 ; + SCIP_VAR *arg1 = (SCIP_VAR *) 0 ; + char *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP_VAR **)&jarg1; + result = (char *)SCIPvarGetName(arg1); + if (result) jresult = jenv->NewStringUTF((const char *)result); + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPvarGetType(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jint jresult = 0 ; + SCIP_VAR *arg1 = (SCIP_VAR *) 0 ; + SCIP_VARTYPE result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP_VAR **)&jarg1; + result = (SCIP_VARTYPE)SCIPvarGetType(arg1); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIPvarGetLbLocal(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jdouble jresult = 0 ; + SCIP_VAR *arg1 = (SCIP_VAR *) 0 ; + double result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP_VAR **)&jarg1; + result = (double)SCIPvarGetLbLocal(arg1); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIPvarGetUbLocal(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jdouble jresult = 0 ; + SCIP_VAR *arg1 = (SCIP_VAR *) 0 ; + double result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP_VAR **)&jarg1; + result = (double)SCIPvarGetUbLocal(arg1); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIPvarGetLbGlobal(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jdouble jresult = 0 ; + SCIP_VAR *arg1 = (SCIP_VAR *) 0 ; + double result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP_VAR **)&jarg1; + result = (double)SCIPvarGetLbGlobal(arg1); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIPvarGetUbGlobal(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jdouble jresult = 0 ; + SCIP_VAR *arg1 = (SCIP_VAR *) 0 ; + double result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP_VAR **)&jarg1; + result = (double)SCIPvarGetUbGlobal(arg1); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIPvarGetObj(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jdouble jresult = 0 ; + SCIP_VAR *arg1 = (SCIP_VAR *) 0 ; + double result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP_VAR **)&jarg1; + result = (double)SCIPvarGetObj(arg1); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPvarGetBranchPriority(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jint jresult = 0 ; + SCIP_VAR *arg1 = (SCIP_VAR *) 0 ; + int result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP_VAR **)&jarg1; + result = (int)SCIPvarGetBranchPriority(arg1); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPsolGetDepth(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jint jresult = 0 ; + SCIP_SOL *arg1 = (SCIP_SOL *) 0 ; + int result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP_SOL **)&jarg1; + result = (int)SCIPsolGetDepth(arg1); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPsolGetIndex(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jint jresult = 0 ; + SCIP_SOL *arg1 = (SCIP_SOL *) 0 ; + int result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP_SOL **)&jarg1; + result = (int)SCIPsolGetIndex(arg1); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jstring JNICALL Java_jscip_SCIPJNIJNI_SCIPconsGetName(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jstring jresult = 0 ; + SCIP_CONS *arg1 = (SCIP_CONS *) 0 ; + char *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP_CONS **)&jarg1; + result = (char *)SCIPconsGetName(arg1); + if (result) jresult = jenv->NewStringUTF((const char *)result); + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPgetDualSolVal(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3, jlong jarg4) { + jint jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + SCIP_CONS *arg2 = (SCIP_CONS *) 0 ; + double *arg3 = (double *) 0 ; + unsigned int *arg4 = (unsigned int *) 0 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = *(SCIP_CONS **)&jarg2; + arg3 = *(double **)&jarg3; + arg4 = *(unsigned int **)&jarg4; + result = (SCIP_RETCODE)SCIPgetDualSolVal(arg1,arg2,arg3,arg4); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIPgetDualsolLinear(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jdouble jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + SCIP_CONS *arg2 = (SCIP_CONS *) 0 ; + double result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = *(SCIP_CONS **)&jarg2; + result = (double)SCIPgetDualsolLinear(arg1,arg2); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIPgetDualfarkasLinear(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jdouble jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + SCIP_CONS *arg2 = (SCIP_CONS *) 0 ; + double result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = *(SCIP_CONS **)&jarg2; + result = (double)SCIPgetDualfarkasLinear(arg1,arg2); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_ObjMessagehdlr_1scip_1bufferedoutput_1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + scip::ObjMessagehdlr *arg1 = (scip::ObjMessagehdlr *) 0 ; + unsigned int result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(scip::ObjMessagehdlr **)&jarg1; + result = (unsigned int)(unsigned int) ((arg1)->scip_bufferedoutput_); + jresult = (jlong)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_new_1ObjMessagehdlr(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jlong jresult = 0 ; + unsigned int arg1 ; + scip::ObjMessagehdlr *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = (unsigned int)jarg1; + result = (scip::ObjMessagehdlr *)new SwigDirector_ObjMessagehdlr(jenv,arg1); + *(scip::ObjMessagehdlr **)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_delete_1ObjMessagehdlr(JNIEnv *jenv, jclass jcls, jlong jarg1) { + scip::ObjMessagehdlr *arg1 = (scip::ObjMessagehdlr *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(scip::ObjMessagehdlr **)&jarg1; + delete arg1; +} + + +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_ObjMessagehdlr_1scip_1error(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jstring jarg4) { + scip::ObjMessagehdlr *arg1 = (scip::ObjMessagehdlr *) 0 ; + SCIP_MESSAGEHDLR *arg2 = (SCIP_MESSAGEHDLR *) 0 ; + FILE *arg3 = (FILE *) 0 ; + char *arg4 = (char *) 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(scip::ObjMessagehdlr **)&jarg1; + arg2 = *(SCIP_MESSAGEHDLR **)&jarg2; + arg3 = *(FILE **)&jarg3; + arg4 = 0; + if (jarg4) { + arg4 = (char *)jenv->GetStringUTFChars(jarg4, 0); + if (!arg4) return ; + } + (arg1)->scip_error(arg2,arg3,(char const *)arg4); + if (arg4) jenv->ReleaseStringUTFChars(jarg4, (const char *)arg4); +} + + +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_ObjMessagehdlr_1scip_1errorSwigExplicitObjMessagehdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jstring jarg4) { + scip::ObjMessagehdlr *arg1 = (scip::ObjMessagehdlr *) 0 ; + SCIP_MESSAGEHDLR *arg2 = (SCIP_MESSAGEHDLR *) 0 ; + FILE *arg3 = (FILE *) 0 ; + char *arg4 = (char *) 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(scip::ObjMessagehdlr **)&jarg1; + arg2 = *(SCIP_MESSAGEHDLR **)&jarg2; + arg3 = *(FILE **)&jarg3; + arg4 = 0; + if (jarg4) { + arg4 = (char *)jenv->GetStringUTFChars(jarg4, 0); + if (!arg4) return ; + } + (arg1)->scip::ObjMessagehdlr::scip_error(arg2,arg3,(char const *)arg4); + if (arg4) jenv->ReleaseStringUTFChars(jarg4, (const char *)arg4); +} + + +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_ObjMessagehdlr_1scip_1warning(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jstring jarg4) { + scip::ObjMessagehdlr *arg1 = (scip::ObjMessagehdlr *) 0 ; + SCIP_MESSAGEHDLR *arg2 = (SCIP_MESSAGEHDLR *) 0 ; + FILE *arg3 = (FILE *) 0 ; + char *arg4 = (char *) 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(scip::ObjMessagehdlr **)&jarg1; + arg2 = *(SCIP_MESSAGEHDLR **)&jarg2; + arg3 = *(FILE **)&jarg3; + arg4 = 0; + if (jarg4) { + arg4 = (char *)jenv->GetStringUTFChars(jarg4, 0); + if (!arg4) return ; + } + (arg1)->scip_warning(arg2,arg3,(char const *)arg4); + if (arg4) jenv->ReleaseStringUTFChars(jarg4, (const char *)arg4); +} + + +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_ObjMessagehdlr_1scip_1warningSwigExplicitObjMessagehdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jstring jarg4) { + scip::ObjMessagehdlr *arg1 = (scip::ObjMessagehdlr *) 0 ; + SCIP_MESSAGEHDLR *arg2 = (SCIP_MESSAGEHDLR *) 0 ; + FILE *arg3 = (FILE *) 0 ; + char *arg4 = (char *) 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(scip::ObjMessagehdlr **)&jarg1; + arg2 = *(SCIP_MESSAGEHDLR **)&jarg2; + arg3 = *(FILE **)&jarg3; + arg4 = 0; + if (jarg4) { + arg4 = (char *)jenv->GetStringUTFChars(jarg4, 0); + if (!arg4) return ; + } + (arg1)->scip::ObjMessagehdlr::scip_warning(arg2,arg3,(char const *)arg4); + if (arg4) jenv->ReleaseStringUTFChars(jarg4, (const char *)arg4); +} + + +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_ObjMessagehdlr_1scip_1dialog(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jstring jarg4) { + scip::ObjMessagehdlr *arg1 = (scip::ObjMessagehdlr *) 0 ; + SCIP_MESSAGEHDLR *arg2 = (SCIP_MESSAGEHDLR *) 0 ; + FILE *arg3 = (FILE *) 0 ; + char *arg4 = (char *) 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(scip::ObjMessagehdlr **)&jarg1; + arg2 = *(SCIP_MESSAGEHDLR **)&jarg2; + arg3 = *(FILE **)&jarg3; + arg4 = 0; + if (jarg4) { + arg4 = (char *)jenv->GetStringUTFChars(jarg4, 0); + if (!arg4) return ; + } + (arg1)->scip_dialog(arg2,arg3,(char const *)arg4); + if (arg4) jenv->ReleaseStringUTFChars(jarg4, (const char *)arg4); +} + + +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_ObjMessagehdlr_1scip_1dialogSwigExplicitObjMessagehdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jstring jarg4) { + scip::ObjMessagehdlr *arg1 = (scip::ObjMessagehdlr *) 0 ; + SCIP_MESSAGEHDLR *arg2 = (SCIP_MESSAGEHDLR *) 0 ; + FILE *arg3 = (FILE *) 0 ; + char *arg4 = (char *) 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(scip::ObjMessagehdlr **)&jarg1; + arg2 = *(SCIP_MESSAGEHDLR **)&jarg2; + arg3 = *(FILE **)&jarg3; + arg4 = 0; + if (jarg4) { + arg4 = (char *)jenv->GetStringUTFChars(jarg4, 0); + if (!arg4) return ; + } + (arg1)->scip::ObjMessagehdlr::scip_dialog(arg2,arg3,(char const *)arg4); + if (arg4) jenv->ReleaseStringUTFChars(jarg4, (const char *)arg4); +} + + +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_ObjMessagehdlr_1scip_1info(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jstring jarg4) { + scip::ObjMessagehdlr *arg1 = (scip::ObjMessagehdlr *) 0 ; + SCIP_MESSAGEHDLR *arg2 = (SCIP_MESSAGEHDLR *) 0 ; + FILE *arg3 = (FILE *) 0 ; + char *arg4 = (char *) 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(scip::ObjMessagehdlr **)&jarg1; + arg2 = *(SCIP_MESSAGEHDLR **)&jarg2; + arg3 = *(FILE **)&jarg3; + arg4 = 0; + if (jarg4) { + arg4 = (char *)jenv->GetStringUTFChars(jarg4, 0); + if (!arg4) return ; + } + (arg1)->scip_info(arg2,arg3,(char const *)arg4); + if (arg4) jenv->ReleaseStringUTFChars(jarg4, (const char *)arg4); +} + + +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_ObjMessagehdlr_1scip_1infoSwigExplicitObjMessagehdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jstring jarg4) { + scip::ObjMessagehdlr *arg1 = (scip::ObjMessagehdlr *) 0 ; + SCIP_MESSAGEHDLR *arg2 = (SCIP_MESSAGEHDLR *) 0 ; + FILE *arg3 = (FILE *) 0 ; + char *arg4 = (char *) 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(scip::ObjMessagehdlr **)&jarg1; + arg2 = *(SCIP_MESSAGEHDLR **)&jarg2; + arg3 = *(FILE **)&jarg3; + arg4 = 0; + if (jarg4) { + arg4 = (char *)jenv->GetStringUTFChars(jarg4, 0); + if (!arg4) return ; + } + (arg1)->scip::ObjMessagehdlr::scip_info(arg2,arg3,(char const *)arg4); + if (arg4) jenv->ReleaseStringUTFChars(jarg4, (const char *)arg4); +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjMessagehdlr_1scip_1free(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jint jresult = 0 ; + scip::ObjMessagehdlr *arg1 = (scip::ObjMessagehdlr *) 0 ; + SCIP_MESSAGEHDLR *arg2 = (SCIP_MESSAGEHDLR *) 0 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(scip::ObjMessagehdlr **)&jarg1; + arg2 = *(SCIP_MESSAGEHDLR **)&jarg2; + result = (SCIP_RETCODE)(arg1)->scip_free(arg2); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjMessagehdlr_1scip_1freeSwigExplicitObjMessagehdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jint jresult = 0 ; + scip::ObjMessagehdlr *arg1 = (scip::ObjMessagehdlr *) 0 ; + SCIP_MESSAGEHDLR *arg2 = (SCIP_MESSAGEHDLR *) 0 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(scip::ObjMessagehdlr **)&jarg1; + arg2 = *(SCIP_MESSAGEHDLR **)&jarg2; + result = (SCIP_RETCODE)(arg1)->scip::ObjMessagehdlr::scip_free(arg2); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_ObjMessagehdlr_1director_1connect(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jswig_mem_own, jboolean jweak_global) { + scip::ObjMessagehdlr *obj = *((scip::ObjMessagehdlr **)&objarg); + (void)jcls; + SwigDirector_ObjMessagehdlr *director = static_cast(obj); + director->swig_connect_director(jenv, jself, jenv->GetObjectClass(jself), (jswig_mem_own == JNI_TRUE), (jweak_global == JNI_TRUE)); +} + + +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_ObjMessagehdlr_1change_1ownership(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jtake_or_release) { + scip::ObjMessagehdlr *obj = *((scip::ObjMessagehdlr **)&objarg); + SwigDirector_ObjMessagehdlr *director = dynamic_cast(obj); + (void)jcls; + if (director) { + director->swig_java_change_ownership(jenv, jself, jtake_or_release ? true : false); + } +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIPgetObjMessagehdlr(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jlong jresult = 0 ; + SCIP_MESSAGEHDLR *arg1 = (SCIP_MESSAGEHDLR *) 0 ; + scip::ObjMessagehdlr *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP_MESSAGEHDLR **)&jarg1; + result = (scip::ObjMessagehdlr *)SCIPgetObjMessagehdlr(arg1); + *(scip::ObjMessagehdlr **)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIPsetStaticErrorPrintingMessagehdlr(JNIEnv *jenv, jclass jcls, jlong jarg1) { + SCIP_MESSAGEHDLR *arg1 = (SCIP_MESSAGEHDLR *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP_MESSAGEHDLR **)&jarg1; + SCIPsetStaticErrorPrintingMessagehdlr(arg1); +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPsetMessagehdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jint jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + SCIP_MESSAGEHDLR *arg2 = (SCIP_MESSAGEHDLR *) 0 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = *(SCIP_MESSAGEHDLR **)&jarg2; + result = (SCIP_RETCODE)SCIPsetMessagehdlr(arg1,arg2); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIPgetMessagehdlr(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jlong jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + SCIP_MESSAGEHDLR *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + result = (SCIP_MESSAGEHDLR *)SCIPgetMessagehdlr(arg1); + *(SCIP_MESSAGEHDLR **)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIPsetMessagehdlrLogfile(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2) { + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return ; + } + SCIPsetMessagehdlrLogfile(arg1,(char const *)arg2); + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPgetVerbLevel(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jint jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + SCIP_VERBLEVEL result; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + result = (SCIP_VERBLEVEL)SCIPgetVerbLevel(arg1); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createSCIP(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + SCIP *result = 0 ; + + (void)jenv; + (void)jcls; + result = (SCIP *)createSCIP(); + *(SCIP **)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_freeSCIP(JNIEnv *jenv, jclass jcls, jlong jarg1) { + SCIP *arg1 = (SCIP *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + freeSCIP(arg1); +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createVar(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jdouble jarg3, jdouble jarg4, jdouble jarg5, jint jarg6) { + jlong jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + double arg3 ; + double arg4 ; + double arg5 ; + SCIP_VARTYPE arg6 ; + SCIP_VAR *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = (double)jarg3; + arg4 = (double)jarg4; + arg5 = (double)jarg5; + arg6 = (SCIP_VARTYPE)jarg6; + result = (SCIP_VAR *)createVar(arg1,(char const *)arg2,arg3,arg4,arg5,arg6); + *(SCIP_VAR **)&jresult = result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + return jresult; +} + + +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_releaseVar(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + SCIP *arg1 = (SCIP *) 0 ; + SCIP_VAR *arg2 = (SCIP_VAR *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = *(SCIP_VAR **)&jarg2; + releaseVar(arg1,arg2); +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createExprAbs(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jlong jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + SCIP_EXPR *arg2 = (SCIP_EXPR *) 0 ; + SCIP_EXPR *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = *(SCIP_EXPR **)&jarg2; + result = (SCIP_EXPR *)createExprAbs(arg1,arg2); + *(SCIP_EXPR **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createExprEntropy(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jlong jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + SCIP_EXPR *arg2 = (SCIP_EXPR *) 0 ; + SCIP_EXPR *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = *(SCIP_EXPR **)&jarg2; + result = (SCIP_EXPR *)createExprEntropy(arg1,arg2); + *(SCIP_EXPR **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createExprExp(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jlong jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + SCIP_EXPR *arg2 = (SCIP_EXPR *) 0 ; + SCIP_EXPR *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = *(SCIP_EXPR **)&jarg2; + result = (SCIP_EXPR *)createExprExp(arg1,arg2); + *(SCIP_EXPR **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createExprLog(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jlong jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + SCIP_EXPR *arg2 = (SCIP_EXPR *) 0 ; + SCIP_EXPR *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = *(SCIP_EXPR **)&jarg2; + result = (SCIP_EXPR *)createExprLog(arg1,arg2); + *(SCIP_EXPR **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createExprPow(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jdouble jarg3) { + jlong jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + SCIP_EXPR *arg2 = (SCIP_EXPR *) 0 ; + double arg3 ; + SCIP_EXPR *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = *(SCIP_EXPR **)&jarg2; + arg3 = (double)jarg3; + result = (SCIP_EXPR *)createExprPow(arg1,arg2,arg3); + *(SCIP_EXPR **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createExprSignpower(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jdouble jarg3) { + jlong jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + SCIP_EXPR *arg2 = (SCIP_EXPR *) 0 ; + double arg3 ; + SCIP_EXPR *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = *(SCIP_EXPR **)&jarg2; + arg3 = (double)jarg3; + result = (SCIP_EXPR *)createExprSignpower(arg1,arg2,arg3); + *(SCIP_EXPR **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createExprProduct(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2, jlong jarg3, jdouble jarg4) { + jlong jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + int arg2 ; + SCIP_EXPR **arg3 = (SCIP_EXPR **) 0 ; + double arg4 ; + SCIP_EXPR *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = (int)jarg2; + arg3 = *(SCIP_EXPR ***)&jarg3; + arg4 = (double)jarg4; + result = (SCIP_EXPR *)createExprProduct(arg1,arg2,arg3,arg4); + *(SCIP_EXPR **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createExprSum(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2, jlong jarg3, jlong jarg4, jdouble jarg5) { + jlong jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + int arg2 ; + SCIP_EXPR **arg3 = (SCIP_EXPR **) 0 ; + double *arg4 = (double *) 0 ; + double arg5 ; + SCIP_EXPR *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = (int)jarg2; + arg3 = *(SCIP_EXPR ***)&jarg3; + arg4 = *(double **)&jarg4; + arg5 = (double)jarg5; + result = (SCIP_EXPR *)createExprSum(arg1,arg2,arg3,arg4,arg5); + *(SCIP_EXPR **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createExprSin(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jlong jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + SCIP_EXPR *arg2 = (SCIP_EXPR *) 0 ; + SCIP_EXPR *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = *(SCIP_EXPR **)&jarg2; + result = (SCIP_EXPR *)createExprSin(arg1,arg2); + *(SCIP_EXPR **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createExprCos(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jlong jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + SCIP_EXPR *arg2 = (SCIP_EXPR *) 0 ; + SCIP_EXPR *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = *(SCIP_EXPR **)&jarg2; + result = (SCIP_EXPR *)createExprCos(arg1,arg2); + *(SCIP_EXPR **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createExprValue(JNIEnv *jenv, jclass jcls, jlong jarg1, jdouble jarg2) { + jlong jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + double arg2 ; + SCIP_EXPR *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = (double)jarg2; + result = (SCIP_EXPR *)createExprValue(arg1,arg2); + *(SCIP_EXPR **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createExprVar(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jlong jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + SCIP_VAR *arg2 = (SCIP_VAR *) 0 ; + SCIP_EXPR *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = *(SCIP_VAR **)&jarg2; + result = (SCIP_EXPR *)createExprVar(arg1,arg2); + *(SCIP_EXPR **)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_releaseExpr(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + SCIP *arg1 = (SCIP *) 0 ; + SCIP_EXPR *arg2 = (SCIP_EXPR *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = *(SCIP_EXPR **)&jarg2; + releaseExpr(arg1,arg2); +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicLinear(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jint jarg3, jlong jarg4, jlong jarg5, jdouble jarg6, jdouble jarg7) { + jlong jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; + SCIP_VAR **arg4 = (SCIP_VAR **) 0 ; + double *arg5 = (double *) 0 ; + double arg6 ; + double arg7 ; + SCIP_CONS *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = (int)jarg3; + arg4 = *(SCIP_VAR ***)&jarg4; + arg5 = *(double **)&jarg5; + arg6 = (double)jarg6; + arg7 = (double)jarg7; + result = (SCIP_CONS *)createConsBasicLinear(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7); + *(SCIP_CONS **)&jresult = result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicQuadratic(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jint jarg3, jlong jarg4, jlong jarg5, jint jarg6, jlong jarg7, jlong jarg8, jlong jarg9, jdouble jarg10, jdouble jarg11) { + jlong jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; + SCIP_VAR **arg4 = (SCIP_VAR **) 0 ; + double *arg5 = (double *) 0 ; + int arg6 ; + SCIP_VAR **arg7 = (SCIP_VAR **) 0 ; + SCIP_VAR **arg8 = (SCIP_VAR **) 0 ; + double *arg9 = (double *) 0 ; + double arg10 ; + double arg11 ; + SCIP_CONS *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = (int)jarg3; + arg4 = *(SCIP_VAR ***)&jarg4; + arg5 = *(double **)&jarg5; + arg6 = (int)jarg6; + arg7 = *(SCIP_VAR ***)&jarg7; + arg8 = *(SCIP_VAR ***)&jarg8; + arg9 = *(double **)&jarg9; + arg10 = (double)jarg10; + arg11 = (double)jarg11; + result = (SCIP_CONS *)createConsBasicQuadratic(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11); + *(SCIP_CONS **)&jresult = result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicNonlinear(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3, jdouble jarg4, jdouble jarg5) { + jlong jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + SCIP_EXPR *arg3 = (SCIP_EXPR *) 0 ; + double arg4 ; + double arg5 ; + SCIP_CONS *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = *(SCIP_EXPR **)&jarg3; + arg4 = (double)jarg4; + arg5 = (double)jarg5; + result = (SCIP_CONS *)createConsBasicNonlinear(arg1,(char const *)arg2,arg3,arg4,arg5); + *(SCIP_CONS **)&jresult = result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicSuperindicator(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3, jlong jarg4) { + jlong jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + SCIP_VAR *arg3 = (SCIP_VAR *) 0 ; + SCIP_CONS *arg4 = (SCIP_CONS *) 0 ; + SCIP_CONS *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = *(SCIP_VAR **)&jarg3; + arg4 = *(SCIP_CONS **)&jarg4; + result = (SCIP_CONS *)createConsBasicSuperindicator(arg1,(char const *)arg2,arg3,arg4); + *(SCIP_CONS **)&jresult = result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicPseudoboolean(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3, jint jarg4, jlong jarg5, jlong jarg6, jint jarg7, jlong jarg8, jlong jarg9, jlong jarg10, jdouble jarg11, jlong jarg12, jlong jarg13, jdouble jarg14, jdouble jarg15) { + jlong jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + SCIP_VAR **arg3 = (SCIP_VAR **) 0 ; + int arg4 ; + double *arg5 = (double *) 0 ; + SCIP_VAR ***arg6 = (SCIP_VAR ***) 0 ; + int arg7 ; + int *arg8 = (int *) 0 ; + double *arg9 = (double *) 0 ; + SCIP_VAR *arg10 = (SCIP_VAR *) 0 ; + double arg11 ; + unsigned int arg12 ; + SCIP_VAR *arg13 = (SCIP_VAR *) 0 ; + double arg14 ; + double arg15 ; + SCIP_CONS *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = *(SCIP_VAR ***)&jarg3; + arg4 = (int)jarg4; + arg5 = *(double **)&jarg5; + arg6 = *(SCIP_VAR ****)&jarg6; + arg7 = (int)jarg7; + arg8 = *(int **)&jarg8; + arg9 = *(double **)&jarg9; + arg10 = *(SCIP_VAR **)&jarg10; + arg11 = (double)jarg11; + arg12 = (unsigned int)jarg12; + arg13 = *(SCIP_VAR **)&jarg13; + arg14 = (double)jarg14; + arg15 = (double)jarg15; + result = (SCIP_CONS *)createConsBasicPseudoboolean(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15); + *(SCIP_CONS **)&jresult = result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicSetpart(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jint jarg3, jlong jarg4) { + jlong jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; + SCIP_VAR **arg4 = (SCIP_VAR **) 0 ; + SCIP_CONS *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = (int)jarg3; + arg4 = *(SCIP_VAR ***)&jarg4; + result = (SCIP_CONS *)createConsBasicSetpart(arg1,(char const *)arg2,arg3,arg4); + *(SCIP_CONS **)&jresult = result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicSetpack(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jint jarg3, jlong jarg4) { + jlong jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; + SCIP_VAR **arg4 = (SCIP_VAR **) 0 ; + SCIP_CONS *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = (int)jarg3; + arg4 = *(SCIP_VAR ***)&jarg4; + result = (SCIP_CONS *)createConsBasicSetpack(arg1,(char const *)arg2,arg3,arg4); + *(SCIP_CONS **)&jresult = result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicSetcover(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jint jarg3, jlong jarg4) { + jlong jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; + SCIP_VAR **arg4 = (SCIP_VAR **) 0 ; + SCIP_CONS *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = (int)jarg3; + arg4 = *(SCIP_VAR ***)&jarg4; + result = (SCIP_CONS *)createConsBasicSetcover(arg1,(char const *)arg2,arg3,arg4); + *(SCIP_CONS **)&jresult = result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicSOC(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jint jarg3, jlong jarg4, jlong jarg5, jlong jarg6, jdouble jarg7, jlong jarg8, jdouble jarg9, jdouble jarg10) { + jlong jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; + SCIP_VAR **arg4 = (SCIP_VAR **) 0 ; + double *arg5 = (double *) 0 ; + double *arg6 = (double *) 0 ; + double arg7 ; + SCIP_VAR *arg8 = (SCIP_VAR *) 0 ; + double arg9 ; + double arg10 ; + SCIP_CONS *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = (int)jarg3; + arg4 = *(SCIP_VAR ***)&jarg4; + arg5 = *(double **)&jarg5; + arg6 = *(double **)&jarg6; + arg7 = (double)jarg7; + arg8 = *(SCIP_VAR **)&jarg8; + arg9 = (double)jarg9; + arg10 = (double)jarg10; + result = (SCIP_CONS *)createConsBasicSOC(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); + *(SCIP_CONS **)&jresult = result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicSignpower(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3, jlong jarg4, jdouble jarg5, jdouble jarg6, jdouble jarg7, jdouble jarg8, jdouble jarg9) { + jlong jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + SCIP_VAR *arg3 = (SCIP_VAR *) 0 ; + SCIP_VAR *arg4 = (SCIP_VAR *) 0 ; + double arg5 ; + double arg6 ; + double arg7 ; + double arg8 ; + double arg9 ; + SCIP_CONS *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = *(SCIP_VAR **)&jarg3; + arg4 = *(SCIP_VAR **)&jarg4; + arg5 = (double)jarg5; + arg6 = (double)jarg6; + arg7 = (double)jarg7; + arg8 = (double)jarg8; + arg9 = (double)jarg9; + result = (SCIP_CONS *)createConsBasicSignpower(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + *(SCIP_CONS **)&jresult = result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicAnd(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3, jint jarg4, jlong jarg5) { + jlong jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + SCIP_VAR *arg3 = (SCIP_VAR *) 0 ; + int arg4 ; + SCIP_VAR **arg5 = (SCIP_VAR **) 0 ; + SCIP_CONS *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = *(SCIP_VAR **)&jarg3; + arg4 = (int)jarg4; + arg5 = *(SCIP_VAR ***)&jarg5; + result = (SCIP_CONS *)createConsBasicAnd(arg1,(char const *)arg2,arg3,arg4,arg5); + *(SCIP_CONS **)&jresult = result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); return jresult; } -SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_delete_1int_1array(JNIEnv *jenv, jclass jcls, jlong jarg1) { - int *arg1 = (int *) 0 ; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicOr(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3, jint jarg4, jlong jarg5) { + jlong jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + SCIP_VAR *arg3 = (SCIP_VAR *) 0 ; + int arg4 ; + SCIP_VAR **arg5 = (SCIP_VAR **) 0 ; + SCIP_CONS *result = 0 ; (void)jenv; (void)jcls; - arg1 = *(int **)&jarg1; - delete_int_array(arg1); + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = *(SCIP_VAR **)&jarg3; + arg4 = (int)jarg4; + arg5 = *(SCIP_VAR ***)&jarg5; + result = (SCIP_CONS *)createConsBasicOr(arg1,(char const *)arg2,arg3,arg4,arg5); + *(SCIP_CONS **)&jresult = result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_int_1array_1getitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) { - jint jresult = 0 ; - int *arg1 = (int *) 0 ; - int arg2 ; - int result; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicBounddisjunction(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jint jarg3, jlong jarg4, jlong jarg5, jlong jarg6) { + jlong jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; + SCIP_VAR **arg4 = (SCIP_VAR **) 0 ; + SCIP_BOUNDTYPE *arg5 = (SCIP_BOUNDTYPE *) 0 ; + double *arg6 = (double *) 0 ; + SCIP_CONS *result = 0 ; (void)jenv; (void)jcls; - arg1 = *(int **)&jarg1; - arg2 = (int)jarg2; - result = (int)int_array_getitem(arg1,arg2); - jresult = (jint)result; + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = (int)jarg3; + arg4 = *(SCIP_VAR ***)&jarg4; + arg5 = *(SCIP_BOUNDTYPE **)&jarg5; + arg6 = *(double **)&jarg6; + result = (SCIP_CONS *)createConsBasicBounddisjunction(arg1,(char const *)arg2,arg3,arg4,arg5,arg6); + *(SCIP_CONS **)&jresult = result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicBounddisjunctionRedundant(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jint jarg3, jlong jarg4, jlong jarg5, jlong jarg6) { + jlong jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; + SCIP_VAR **arg4 = (SCIP_VAR **) 0 ; + SCIP_BOUNDTYPE *arg5 = (SCIP_BOUNDTYPE *) 0 ; + double *arg6 = (double *) 0 ; + SCIP_CONS *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = (int)jarg3; + arg4 = *(SCIP_VAR ***)&jarg4; + arg5 = *(SCIP_BOUNDTYPE **)&jarg5; + arg6 = *(double **)&jarg6; + result = (SCIP_CONS *)createConsBasicBounddisjunctionRedundant(arg1,(char const *)arg2,arg3,arg4,arg5,arg6); + *(SCIP_CONS **)&jresult = result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicCardinality(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jint jarg3, jlong jarg4, jint jarg5, jlong jarg6, jlong jarg7) { + jlong jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; + SCIP_VAR **arg4 = (SCIP_VAR **) 0 ; + int arg5 ; + SCIP_VAR **arg6 = (SCIP_VAR **) 0 ; + double *arg7 = (double *) 0 ; + SCIP_CONS *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = (int)jarg3; + arg4 = *(SCIP_VAR ***)&jarg4; + arg5 = (int)jarg5; + arg6 = *(SCIP_VAR ***)&jarg6; + arg7 = *(double **)&jarg7; + result = (SCIP_CONS *)createConsBasicCardinality(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7); + *(SCIP_CONS **)&jresult = result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicConjunction(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jint jarg3, jlong jarg4) { + jlong jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; + SCIP_CONS **arg4 = (SCIP_CONS **) 0 ; + SCIP_CONS *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = (int)jarg3; + arg4 = *(SCIP_CONS ***)&jarg4; + result = (SCIP_CONS *)createConsBasicConjunction(arg1,(char const *)arg2,arg3,arg4); + *(SCIP_CONS **)&jresult = result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicDisjunction(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jint jarg3, jlong jarg4, jlong jarg5) { + jlong jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; + SCIP_CONS **arg4 = (SCIP_CONS **) 0 ; + SCIP_CONS *arg5 = (SCIP_CONS *) 0 ; + SCIP_CONS *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = (int)jarg3; + arg4 = *(SCIP_CONS ***)&jarg4; + arg5 = *(SCIP_CONS **)&jarg5; + result = (SCIP_CONS *)createConsBasicDisjunction(arg1,(char const *)arg2,arg3,arg4,arg5); + *(SCIP_CONS **)&jresult = result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicCumulative(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jint jarg3, jlong jarg4, jlong jarg5, jlong jarg6, jint jarg7) { + jlong jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; + SCIP_VAR **arg4 = (SCIP_VAR **) 0 ; + int *arg5 = (int *) 0 ; + int *arg6 = (int *) 0 ; + int arg7 ; + SCIP_CONS *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = (int)jarg3; + arg4 = *(SCIP_VAR ***)&jarg4; + arg5 = *(int **)&jarg5; + arg6 = *(int **)&jarg6; + arg7 = (int)jarg7; + result = (SCIP_CONS *)createConsBasicCumulative(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7); + *(SCIP_CONS **)&jresult = result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicIndicator(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3, jint jarg4, jlong jarg5, jlong jarg6, jdouble jarg7) { + jlong jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + SCIP_VAR *arg3 = (SCIP_VAR *) 0 ; + int arg4 ; + SCIP_VAR **arg5 = (SCIP_VAR **) 0 ; + double *arg6 = (double *) 0 ; + double arg7 ; + SCIP_CONS *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = *(SCIP_VAR **)&jarg3; + arg4 = (int)jarg4; + arg5 = *(SCIP_VAR ***)&jarg5; + arg6 = *(double **)&jarg6; + arg7 = (double)jarg7; + result = (SCIP_CONS *)createConsBasicIndicator(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7); + *(SCIP_CONS **)&jresult = result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicIndicatorLinCons(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3, jlong jarg4, jlong jarg5) { + jlong jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + SCIP_VAR *arg3 = (SCIP_VAR *) 0 ; + SCIP_CONS *arg4 = (SCIP_CONS *) 0 ; + SCIP_VAR *arg5 = (SCIP_VAR *) 0 ; + SCIP_CONS *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = *(SCIP_VAR **)&jarg3; + arg4 = *(SCIP_CONS **)&jarg4; + arg5 = *(SCIP_VAR **)&jarg5; + result = (SCIP_CONS *)createConsBasicIndicatorLinCons(arg1,(char const *)arg2,arg3,arg4,arg5); + *(SCIP_CONS **)&jresult = result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); return jresult; } -SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_int_1array_1setitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2, jint jarg3) { - int *arg1 = (int *) 0 ; - int arg2 ; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicKnapsack(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jint jarg3, jlong jarg4, jlong jarg5, jlong jarg6) { + jlong jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; int arg3 ; + SCIP_VAR **arg4 = (SCIP_VAR **) 0 ; + long long *arg5 = (long long *) 0 ; + long long arg6 ; + SCIP_CONS *result = 0 ; (void)jenv; (void)jcls; - arg1 = *(int **)&jarg1; - arg2 = (int)jarg2; + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } arg3 = (int)jarg3; - int_array_setitem(arg1,arg2,arg3); + arg4 = *(SCIP_VAR ***)&jarg4; + arg5 = *(long long **)&jarg5; + arg6 = (long long)jarg6; + result = (SCIP_CONS *)createConsBasicKnapsack(arg1,(char const *)arg2,arg3,arg4,arg5,arg6); + *(SCIP_CONS **)&jresult = result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_new_1long_1long_1array(JNIEnv *jenv, jclass jcls, jint jarg1) { +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicLinking(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3, jlong jarg4, jlong jarg5, jint jarg6) { jlong jresult = 0 ; - int arg1 ; - long long *result = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + SCIP_VAR *arg3 = (SCIP_VAR *) 0 ; + SCIP_VAR **arg4 = (SCIP_VAR **) 0 ; + double *arg5 = (double *) 0 ; + int arg6 ; + SCIP_CONS *result = 0 ; (void)jenv; (void)jcls; - arg1 = (int)jarg1; - result = (long long *)new_long_long_array(arg1); - *(long long **)&jresult = result; + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = *(SCIP_VAR **)&jarg3; + arg4 = *(SCIP_VAR ***)&jarg4; + arg5 = *(double **)&jarg5; + arg6 = (int)jarg6; + result = (SCIP_CONS *)createConsBasicLinking(arg1,(char const *)arg2,arg3,arg4,arg5,arg6); + *(SCIP_CONS **)&jresult = result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); return jresult; } -SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_delete_1long_1long_1array(JNIEnv *jenv, jclass jcls, jlong jarg1) { - long long *arg1 = (long long *) 0 ; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicLogicor(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jint jarg3, jlong jarg4) { + jlong jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; + SCIP_VAR **arg4 = (SCIP_VAR **) 0 ; + SCIP_CONS *result = 0 ; (void)jenv; (void)jcls; - arg1 = *(long long **)&jarg1; - delete_long_long_array(arg1); + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = (int)jarg3; + arg4 = *(SCIP_VAR ***)&jarg4; + result = (SCIP_CONS *)createConsBasicLogicor(arg1,(char const *)arg2,arg3,arg4); + *(SCIP_CONS **)&jresult = result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_long_1long_1array_1getitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) { +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicOrbisack(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3, jlong jarg4, jint jarg5, jlong jarg6, jlong jarg7, jlong jarg8) { jlong jresult = 0 ; - long long *arg1 = (long long *) 0 ; - int arg2 ; - long long result; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + SCIP_VAR **arg3 = (SCIP_VAR **) 0 ; + SCIP_VAR **arg4 = (SCIP_VAR **) 0 ; + int arg5 ; + unsigned int arg6 ; + unsigned int arg7 ; + unsigned int arg8 ; + SCIP_CONS *result = 0 ; (void)jenv; (void)jcls; - arg1 = *(long long **)&jarg1; - arg2 = (int)jarg2; - result = (long long)long_long_array_getitem(arg1,arg2); - jresult = (jlong)result; + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = *(SCIP_VAR ***)&jarg3; + arg4 = *(SCIP_VAR ***)&jarg4; + arg5 = (int)jarg5; + arg6 = (unsigned int)jarg6; + arg7 = (unsigned int)jarg7; + arg8 = (unsigned int)jarg8; + result = (SCIP_CONS *)createConsBasicOrbisack(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8); + *(SCIP_CONS **)&jresult = result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); return jresult; } -SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_long_1long_1array_1setitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2, jlong jarg3) { - long long *arg1 = (long long *) 0 ; - int arg2 ; - long long arg3 ; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicOrbitope(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3, jint jarg4, jint jarg5, jint jarg6, jlong jarg7, jlong jarg8, jlong jarg9, jlong jarg10) { + jlong jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + SCIP_VAR ***arg3 = (SCIP_VAR ***) 0 ; + SCIP_ORBITOPETYPE arg4 ; + int arg5 ; + int arg6 ; + unsigned int arg7 ; + unsigned int arg8 ; + unsigned int arg9 ; + unsigned int arg10 ; + SCIP_CONS *result = 0 ; (void)jenv; (void)jcls; - arg1 = *(long long **)&jarg1; - arg2 = (int)jarg2; - arg3 = (long long)jarg3; - long_long_array_setitem(arg1,arg2,arg3); + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = *(SCIP_VAR ****)&jarg3; + arg4 = (SCIP_ORBITOPETYPE)jarg4; + arg5 = (int)jarg5; + arg6 = (int)jarg6; + arg7 = (unsigned int)jarg7; + arg8 = (unsigned int)jarg8; + arg9 = (unsigned int)jarg9; + arg10 = (unsigned int)jarg10; + result = (SCIP_CONS *)createConsBasicOrbitope(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); + *(SCIP_CONS **)&jresult = result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_new_1unsigned_1int_1array(JNIEnv *jenv, jclass jcls, jint jarg1) { +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicSOS1(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jint jarg3, jlong jarg4, jlong jarg5) { jlong jresult = 0 ; - int arg1 ; - unsigned int *result = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; + SCIP_VAR **arg4 = (SCIP_VAR **) 0 ; + double *arg5 = (double *) 0 ; + SCIP_CONS *result = 0 ; (void)jenv; (void)jcls; - arg1 = (int)jarg1; - result = (unsigned int *)new_unsigned_int_array(arg1); - *(unsigned int **)&jresult = result; + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = (int)jarg3; + arg4 = *(SCIP_VAR ***)&jarg4; + arg5 = *(double **)&jarg5; + result = (SCIP_CONS *)createConsBasicSOS1(arg1,(char const *)arg2,arg3,arg4,arg5); + *(SCIP_CONS **)&jresult = result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); return jresult; } -SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_delete_1unsigned_1int_1array(JNIEnv *jenv, jclass jcls, jlong jarg1) { - unsigned int *arg1 = (unsigned int *) 0 ; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicSOS2(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jint jarg3, jlong jarg4, jlong jarg5) { + jlong jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; + SCIP_VAR **arg4 = (SCIP_VAR **) 0 ; + double *arg5 = (double *) 0 ; + SCIP_CONS *result = 0 ; (void)jenv; (void)jcls; - arg1 = *(unsigned int **)&jarg1; - delete_unsigned_int_array(arg1); + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = (int)jarg3; + arg4 = *(SCIP_VAR ***)&jarg4; + arg5 = *(double **)&jarg5; + result = (SCIP_CONS *)createConsBasicSOS2(arg1,(char const *)arg2,arg3,arg4,arg5); + *(SCIP_CONS **)&jresult = result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_unsigned_1int_1array_1getitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) { +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicSymresack(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3, jlong jarg4, jint jarg5, jlong jarg6) { jlong jresult = 0 ; - unsigned int *arg1 = (unsigned int *) 0 ; - int arg2 ; - unsigned int result; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + int *arg3 = (int *) 0 ; + SCIP_VAR **arg4 = (SCIP_VAR **) 0 ; + int arg5 ; + unsigned int arg6 ; + SCIP_CONS *result = 0 ; (void)jenv; (void)jcls; - arg1 = *(unsigned int **)&jarg1; - arg2 = (int)jarg2; - result = (unsigned int)unsigned_int_array_getitem(arg1,arg2); - jresult = (jlong)result; + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = *(int **)&jarg3; + arg4 = *(SCIP_VAR ***)&jarg4; + arg5 = (int)jarg5; + arg6 = (unsigned int)jarg6; + result = (SCIP_CONS *)createConsBasicSymresack(arg1,(char const *)arg2,arg3,arg4,arg5,arg6); + *(SCIP_CONS **)&jresult = result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); return jresult; } -SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_unsigned_1int_1array_1setitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2, jlong jarg3) { - unsigned int *arg1 = (unsigned int *) 0 ; - int arg2 ; - unsigned int arg3 ; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicVarbound(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3, jlong jarg4, jdouble jarg5, jdouble jarg6, jdouble jarg7) { + jlong jresult = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + SCIP_VAR *arg3 = (SCIP_VAR *) 0 ; + SCIP_VAR *arg4 = (SCIP_VAR *) 0 ; + double arg5 ; + double arg6 ; + double arg7 ; + SCIP_CONS *result = 0 ; (void)jenv; (void)jcls; - arg1 = *(unsigned int **)&jarg1; - arg2 = (int)jarg2; - arg3 = (unsigned int)jarg3; - unsigned_int_array_setitem(arg1,arg2,arg3); + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = *(SCIP_VAR **)&jarg3; + arg4 = *(SCIP_VAR **)&jarg4; + arg5 = (double)jarg5; + arg6 = (double)jarg6; + arg7 = (double)jarg7; + result = (SCIP_CONS *)createConsBasicVarbound(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7); + *(SCIP_CONS **)&jresult = result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_new_1SCIP_1BoundType_1array(JNIEnv *jenv, jclass jcls, jint jarg1) { +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicXor(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3, jint jarg4, jlong jarg5) { jlong jresult = 0 ; - int arg1 ; - SCIP_BOUNDTYPE *result = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + unsigned int arg3 ; + int arg4 ; + SCIP_VAR **arg5 = (SCIP_VAR **) 0 ; + SCIP_CONS *result = 0 ; (void)jenv; (void)jcls; - arg1 = (int)jarg1; - result = (SCIP_BOUNDTYPE *)new_SCIP_BoundType_array(arg1); - *(SCIP_BOUNDTYPE **)&jresult = result; + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = (unsigned int)jarg3; + arg4 = (int)jarg4; + arg5 = *(SCIP_VAR ***)&jarg5; + result = (SCIP_CONS *)createConsBasicXor(arg1,(char const *)arg2,arg3,arg4,arg5); + *(SCIP_CONS **)&jresult = result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); return jresult; } -SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_delete_1SCIP_1BoundType_1array(JNIEnv *jenv, jclass jcls, jlong jarg1) { - SCIP_BOUNDTYPE *arg1 = (SCIP_BOUNDTYPE *) 0 ; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_releaseCons(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + SCIP *arg1 = (SCIP *) 0 ; + SCIP_CONS *arg2 = (SCIP_CONS *) 0 ; (void)jenv; (void)jcls; - arg1 = *(SCIP_BOUNDTYPE **)&jarg1; - delete_SCIP_BoundType_array(arg1); + arg1 = *(SCIP **)&jarg1; + arg2 = *(SCIP_CONS **)&jarg2; + releaseCons(arg1,arg2); } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1BoundType_1array_1getitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) { - jint jresult = 0 ; - SCIP_BOUNDTYPE *arg1 = (SCIP_BOUNDTYPE *) 0 ; - int arg2 ; - SCIP_BOUNDTYPE result; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createObjMessagehdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jlong jresult = 0 ; + scip::ObjMessagehdlr *arg1 = (scip::ObjMessagehdlr *) 0 ; + unsigned int arg2 ; + SCIP_MESSAGEHDLR *result = 0 ; (void)jenv; (void)jcls; - arg1 = *(SCIP_BOUNDTYPE **)&jarg1; - arg2 = (int)jarg2; - result = (SCIP_BOUNDTYPE)SCIP_BoundType_array_getitem(arg1,arg2); - jresult = (jint)result; + (void)jarg1_; + arg1 = *(scip::ObjMessagehdlr **)&jarg1; + arg2 = (unsigned int)jarg2; + result = (SCIP_MESSAGEHDLR *)createObjMessagehdlr(arg1,arg2); + *(SCIP_MESSAGEHDLR **)&jresult = result; return jresult; } -SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIP_1BoundType_1array_1setitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2, jint jarg3) { - SCIP_BOUNDTYPE *arg1 = (SCIP_BOUNDTYPE *) 0 ; - int arg2 ; - SCIP_BOUNDTYPE arg3 ; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventVarAdded_1var_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + SCIP_EventVarAdded *arg1 = (SCIP_EventVarAdded *) 0 ; + SCIP_VAR *arg2 = (SCIP_VAR *) 0 ; (void)jenv; (void)jcls; - arg1 = *(SCIP_BOUNDTYPE **)&jarg1; - arg2 = (int)jarg2; - arg3 = (SCIP_BOUNDTYPE)jarg3; - SCIP_BoundType_array_setitem(arg1,arg2,arg3); + (void)jarg1_; + arg1 = *(SCIP_EventVarAdded **)&jarg1; + arg2 = *(SCIP_VAR **)&jarg2; + if (arg1) (arg1)->var = arg2; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_new_1String_1array(JNIEnv *jenv, jclass jcls, jint jarg1) { +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventVarAdded_1var_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; - int arg1 ; - char **result = 0 ; + SCIP_EventVarAdded *arg1 = (SCIP_EventVarAdded *) 0 ; + SCIP_VAR *result = 0 ; (void)jenv; (void)jcls; - arg1 = (int)jarg1; - result = (char **)new_String_array(arg1); - *(char ***)&jresult = result; + (void)jarg1_; + arg1 = *(SCIP_EventVarAdded **)&jarg1; + result = (SCIP_VAR *) ((arg1)->var); + *(SCIP_VAR **)&jresult = result; return jresult; } -SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_delete_1String_1array(JNIEnv *jenv, jclass jcls, jlong jarg1) { - char **arg1 = (char **) 0 ; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_new_1SCIP_1EventVarAdded(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + SCIP_EventVarAdded *result = 0 ; (void)jenv; (void)jcls; - arg1 = *(char ***)&jarg1; - delete_String_array(arg1); + result = (SCIP_EventVarAdded *)new SCIP_EventVarAdded(); + *(SCIP_EventVarAdded **)&jresult = result; + return jresult; } -SWIGEXPORT jstring JNICALL Java_jscip_SCIPJNIJNI_String_1array_1getitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) { - jstring jresult = 0 ; - char **arg1 = (char **) 0 ; - int arg2 ; - char *result = 0 ; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_delete_1SCIP_1EventVarAdded(JNIEnv *jenv, jclass jcls, jlong jarg1) { + SCIP_EventVarAdded *arg1 = (SCIP_EventVarAdded *) 0 ; (void)jenv; (void)jcls; - arg1 = *(char ***)&jarg1; - arg2 = (int)jarg2; - result = (char *)String_array_getitem(arg1,arg2); - if (result) jresult = jenv->NewStringUTF((const char *)result); - return jresult; + arg1 = *(SCIP_EventVarAdded **)&jarg1; + delete arg1; } -SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_String_1array_1setitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2, jstring jarg3) { - char **arg1 = (char **) 0 ; - int arg2 ; - char *arg3 = (char *) 0 ; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventVarDeleted_1var_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + SCIP_EventVarDeleted *arg1 = (SCIP_EventVarDeleted *) 0 ; + SCIP_VAR *arg2 = (SCIP_VAR *) 0 ; (void)jenv; (void)jcls; - arg1 = *(char ***)&jarg1; - arg2 = (int)jarg2; - arg3 = 0; - if (jarg3) { - arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0); - if (!arg3) return ; - } - String_array_setitem(arg1,arg2,arg3); - if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3); + (void)jarg1_; + arg1 = *(SCIP_EventVarDeleted **)&jarg1; + arg2 = *(SCIP_VAR **)&jarg2; + if (arg1) (arg1)->var = arg2; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_new_1SCIP_1VAR_1array(JNIEnv *jenv, jclass jcls, jint jarg1) { +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventVarDeleted_1var_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; - int arg1 ; - SCIP_VAR **result = 0 ; + SCIP_EventVarDeleted *arg1 = (SCIP_EventVarDeleted *) 0 ; + SCIP_VAR *result = 0 ; (void)jenv; (void)jcls; - arg1 = (int)jarg1; - result = (SCIP_VAR **)new_SCIP_VAR_array(arg1); - *(SCIP_VAR ***)&jresult = result; + (void)jarg1_; + arg1 = *(SCIP_EventVarDeleted **)&jarg1; + result = (SCIP_VAR *) ((arg1)->var); + *(SCIP_VAR **)&jresult = result; return jresult; } -SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_delete_1SCIP_1VAR_1array(JNIEnv *jenv, jclass jcls, jlong jarg1) { - SCIP_VAR **arg1 = (SCIP_VAR **) 0 ; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_new_1SCIP_1EventVarDeleted(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + SCIP_EventVarDeleted *result = 0 ; (void)jenv; (void)jcls; - arg1 = *(SCIP_VAR ***)&jarg1; - delete_SCIP_VAR_array(arg1); + result = (SCIP_EventVarDeleted *)new SCIP_EventVarDeleted(); + *(SCIP_EventVarDeleted **)&jresult = result; + return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIP_1VAR_1array_1getitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) { - jlong jresult = 0 ; - SCIP_VAR **arg1 = (SCIP_VAR **) 0 ; - int arg2 ; - SCIP_VAR *result = 0 ; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_delete_1SCIP_1EventVarDeleted(JNIEnv *jenv, jclass jcls, jlong jarg1) { + SCIP_EventVarDeleted *arg1 = (SCIP_EventVarDeleted *) 0 ; (void)jenv; (void)jcls; - arg1 = *(SCIP_VAR ***)&jarg1; - arg2 = (int)jarg2; - result = (SCIP_VAR *)SCIP_VAR_array_getitem(arg1,arg2); - *(SCIP_VAR **)&jresult = result; - return jresult; + arg1 = *(SCIP_EventVarDeleted **)&jarg1; + delete arg1; } -SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIP_1VAR_1array_1setitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2, jlong jarg3) { - SCIP_VAR **arg1 = (SCIP_VAR **) 0 ; - int arg2 ; - SCIP_VAR *arg3 = (SCIP_VAR *) 0 ; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventVarFixed_1var_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + SCIP_EventVarFixed *arg1 = (SCIP_EventVarFixed *) 0 ; + SCIP_VAR *arg2 = (SCIP_VAR *) 0 ; (void)jenv; (void)jcls; - arg1 = *(SCIP_VAR ***)&jarg1; - arg2 = (int)jarg2; - arg3 = *(SCIP_VAR **)&jarg3; - SCIP_VAR_array_setitem(arg1,arg2,arg3); + (void)jarg1_; + arg1 = *(SCIP_EventVarFixed **)&jarg1; + arg2 = *(SCIP_VAR **)&jarg2; + if (arg1) (arg1)->var = arg2; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_new_1SCIP_1EXPR_1array(JNIEnv *jenv, jclass jcls, jint jarg1) { +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventVarFixed_1var_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; - int arg1 ; - SCIP_EXPR **result = 0 ; + SCIP_EventVarFixed *arg1 = (SCIP_EventVarFixed *) 0 ; + SCIP_VAR *result = 0 ; (void)jenv; (void)jcls; - arg1 = (int)jarg1; - result = (SCIP_EXPR **)new_SCIP_EXPR_array(arg1); - *(SCIP_EXPR ***)&jresult = result; + (void)jarg1_; + arg1 = *(SCIP_EventVarFixed **)&jarg1; + result = (SCIP_VAR *) ((arg1)->var); + *(SCIP_VAR **)&jresult = result; return jresult; } -SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_delete_1SCIP_1EXPR_1array(JNIEnv *jenv, jclass jcls, jlong jarg1) { - SCIP_EXPR **arg1 = (SCIP_EXPR **) 0 ; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_new_1SCIP_1EventVarFixed(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + SCIP_EventVarFixed *result = 0 ; (void)jenv; (void)jcls; - arg1 = *(SCIP_EXPR ***)&jarg1; - delete_SCIP_EXPR_array(arg1); + result = (SCIP_EventVarFixed *)new SCIP_EventVarFixed(); + *(SCIP_EventVarFixed **)&jresult = result; + return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EXPR_1array_1getitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) { - jlong jresult = 0 ; - SCIP_EXPR **arg1 = (SCIP_EXPR **) 0 ; - int arg2 ; - SCIP_EXPR *result = 0 ; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_delete_1SCIP_1EventVarFixed(JNIEnv *jenv, jclass jcls, jlong jarg1) { + SCIP_EventVarFixed *arg1 = (SCIP_EventVarFixed *) 0 ; (void)jenv; (void)jcls; - arg1 = *(SCIP_EXPR ***)&jarg1; - arg2 = (int)jarg2; - result = (SCIP_EXPR *)SCIP_EXPR_array_getitem(arg1,arg2); - *(SCIP_EXPR **)&jresult = result; - return jresult; + arg1 = *(SCIP_EventVarFixed **)&jarg1; + delete arg1; } -SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EXPR_1array_1setitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2, jlong jarg3) { - SCIP_EXPR **arg1 = (SCIP_EXPR **) 0 ; - int arg2 ; - SCIP_EXPR *arg3 = (SCIP_EXPR *) 0 ; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventVarUnlocked_1var_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + SCIP_EventVarUnlocked *arg1 = (SCIP_EventVarUnlocked *) 0 ; + SCIP_VAR *arg2 = (SCIP_VAR *) 0 ; (void)jenv; (void)jcls; - arg1 = *(SCIP_EXPR ***)&jarg1; - arg2 = (int)jarg2; - arg3 = *(SCIP_EXPR **)&jarg3; - SCIP_EXPR_array_setitem(arg1,arg2,arg3); + (void)jarg1_; + arg1 = *(SCIP_EventVarUnlocked **)&jarg1; + arg2 = *(SCIP_VAR **)&jarg2; + if (arg1) (arg1)->var = arg2; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_new_1SCIP_1CONS_1array(JNIEnv *jenv, jclass jcls, jint jarg1) { +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventVarUnlocked_1var_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; - int arg1 ; - SCIP_CONS **result = 0 ; + SCIP_EventVarUnlocked *arg1 = (SCIP_EventVarUnlocked *) 0 ; + SCIP_VAR *result = 0 ; (void)jenv; (void)jcls; - arg1 = (int)jarg1; - result = (SCIP_CONS **)new_SCIP_CONS_array(arg1); - *(SCIP_CONS ***)&jresult = result; + (void)jarg1_; + arg1 = *(SCIP_EventVarUnlocked **)&jarg1; + result = (SCIP_VAR *) ((arg1)->var); + *(SCIP_VAR **)&jresult = result; return jresult; } -SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_delete_1SCIP_1CONS_1array(JNIEnv *jenv, jclass jcls, jlong jarg1) { - SCIP_CONS **arg1 = (SCIP_CONS **) 0 ; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_new_1SCIP_1EventVarUnlocked(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + SCIP_EventVarUnlocked *result = 0 ; (void)jenv; (void)jcls; - arg1 = *(SCIP_CONS ***)&jarg1; - delete_SCIP_CONS_array(arg1); + result = (SCIP_EventVarUnlocked *)new SCIP_EventVarUnlocked(); + *(SCIP_EventVarUnlocked **)&jresult = result; + return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIP_1CONS_1array_1getitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) { - jlong jresult = 0 ; - SCIP_CONS **arg1 = (SCIP_CONS **) 0 ; - int arg2 ; - SCIP_CONS *result = 0 ; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_delete_1SCIP_1EventVarUnlocked(JNIEnv *jenv, jclass jcls, jlong jarg1) { + SCIP_EventVarUnlocked *arg1 = (SCIP_EventVarUnlocked *) 0 ; (void)jenv; (void)jcls; - arg1 = *(SCIP_CONS ***)&jarg1; - arg2 = (int)jarg2; - result = (SCIP_CONS *)SCIP_CONS_array_getitem(arg1,arg2); - *(SCIP_CONS **)&jresult = result; - return jresult; + arg1 = *(SCIP_EventVarUnlocked **)&jarg1; + delete arg1; } -SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIP_1CONS_1array_1setitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2, jlong jarg3) { - SCIP_CONS **arg1 = (SCIP_CONS **) 0 ; - int arg2 ; - SCIP_CONS *arg3 = (SCIP_CONS *) 0 ; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventObjChg_1oldobj_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) { + SCIP_EventObjChg *arg1 = (SCIP_EventObjChg *) 0 ; + double arg2 ; (void)jenv; (void)jcls; - arg1 = *(SCIP_CONS ***)&jarg1; - arg2 = (int)jarg2; - arg3 = *(SCIP_CONS **)&jarg3; - SCIP_CONS_array_setitem(arg1,arg2,arg3); + (void)jarg1_; + arg1 = *(SCIP_EventObjChg **)&jarg1; + arg2 = (double)jarg2; + if (arg1) (arg1)->oldobj = arg2; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_new_1SCIP_1SOL_1array(JNIEnv *jenv, jclass jcls, jint jarg1) { - jlong jresult = 0 ; - int arg1 ; - SCIP_SOL **result = 0 ; +SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventObjChg_1oldobj_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jdouble jresult = 0 ; + SCIP_EventObjChg *arg1 = (SCIP_EventObjChg *) 0 ; + double result; (void)jenv; (void)jcls; - arg1 = (int)jarg1; - result = (SCIP_SOL **)new_SCIP_SOL_array(arg1); - *(SCIP_SOL ***)&jresult = result; + (void)jarg1_; + arg1 = *(SCIP_EventObjChg **)&jarg1; + result = (double) ((arg1)->oldobj); + jresult = (jdouble)result; return jresult; } -SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_delete_1SCIP_1SOL_1array(JNIEnv *jenv, jclass jcls, jlong jarg1) { - SCIP_SOL **arg1 = (SCIP_SOL **) 0 ; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventObjChg_1newobj_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) { + SCIP_EventObjChg *arg1 = (SCIP_EventObjChg *) 0 ; + double arg2 ; (void)jenv; (void)jcls; - arg1 = *(SCIP_SOL ***)&jarg1; - delete_SCIP_SOL_array(arg1); + (void)jarg1_; + arg1 = *(SCIP_EventObjChg **)&jarg1; + arg2 = (double)jarg2; + if (arg1) (arg1)->newobj = arg2; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIP_1SOL_1array_1getitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) { - jlong jresult = 0 ; - SCIP_SOL **arg1 = (SCIP_SOL **) 0 ; - int arg2 ; - SCIP_SOL *result = 0 ; +SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventObjChg_1newobj_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jdouble jresult = 0 ; + SCIP_EventObjChg *arg1 = (SCIP_EventObjChg *) 0 ; + double result; (void)jenv; (void)jcls; - arg1 = *(SCIP_SOL ***)&jarg1; - arg2 = (int)jarg2; - result = (SCIP_SOL *)SCIP_SOL_array_getitem(arg1,arg2); - *(SCIP_SOL **)&jresult = result; + (void)jarg1_; + arg1 = *(SCIP_EventObjChg **)&jarg1; + result = (double) ((arg1)->newobj); + jresult = (jdouble)result; return jresult; } -SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIP_1SOL_1array_1setitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2, jlong jarg3) { - SCIP_SOL **arg1 = (SCIP_SOL **) 0 ; - int arg2 ; - SCIP_SOL *arg3 = (SCIP_SOL *) 0 ; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventObjChg_1var_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + SCIP_EventObjChg *arg1 = (SCIP_EventObjChg *) 0 ; + SCIP_VAR *arg2 = (SCIP_VAR *) 0 ; (void)jenv; (void)jcls; - arg1 = *(SCIP_SOL ***)&jarg1; - arg2 = (int)jarg2; - arg3 = *(SCIP_SOL **)&jarg3; - SCIP_SOL_array_setitem(arg1,arg2,arg3); + (void)jarg1_; + arg1 = *(SCIP_EventObjChg **)&jarg1; + arg2 = *(SCIP_VAR **)&jarg2; + if (arg1) (arg1)->var = arg2; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_new_1SCIP_1VAR_1array_1array(JNIEnv *jenv, jclass jcls, jint jarg1) { +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventObjChg_1var_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; - int arg1 ; - SCIP_VAR ***result = 0 ; + SCIP_EventObjChg *arg1 = (SCIP_EventObjChg *) 0 ; + SCIP_VAR *result = 0 ; (void)jenv; (void)jcls; - arg1 = (int)jarg1; - result = (SCIP_VAR ***)new_SCIP_VAR_array_array(arg1); - *(SCIP_VAR ****)&jresult = result; + (void)jarg1_; + arg1 = *(SCIP_EventObjChg **)&jarg1; + result = (SCIP_VAR *) ((arg1)->var); + *(SCIP_VAR **)&jresult = result; return jresult; } -SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_delete_1SCIP_1VAR_1array_1array(JNIEnv *jenv, jclass jcls, jlong jarg1) { - SCIP_VAR ***arg1 = (SCIP_VAR ***) 0 ; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_new_1SCIP_1EventObjChg(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + SCIP_EventObjChg *result = 0 ; (void)jenv; (void)jcls; - arg1 = *(SCIP_VAR ****)&jarg1; - delete_SCIP_VAR_array_array(arg1); + result = (SCIP_EventObjChg *)new SCIP_EventObjChg(); + *(SCIP_EventObjChg **)&jresult = result; + return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIP_1VAR_1array_1array_1getitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) { - jlong jresult = 0 ; - SCIP_VAR ***arg1 = (SCIP_VAR ***) 0 ; - int arg2 ; - SCIP_VAR **result = 0 ; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_delete_1SCIP_1EventObjChg(JNIEnv *jenv, jclass jcls, jlong jarg1) { + SCIP_EventObjChg *arg1 = (SCIP_EventObjChg *) 0 ; (void)jenv; (void)jcls; - arg1 = *(SCIP_VAR ****)&jarg1; - arg2 = (int)jarg2; - result = (SCIP_VAR **)SCIP_VAR_array_array_getitem(arg1,arg2); - *(SCIP_VAR ***)&jresult = result; - return jresult; + arg1 = *(SCIP_EventObjChg **)&jarg1; + delete arg1; } -SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIP_1VAR_1array_1array_1setitem(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2, jlong jarg3) { - SCIP_VAR ***arg1 = (SCIP_VAR ***) 0 ; - int arg2 ; - SCIP_VAR **arg3 = (SCIP_VAR **) 0 ; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventBdChg_1oldbound_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) { + SCIP_EventBdChg *arg1 = (SCIP_EventBdChg *) 0 ; + double arg2 ; (void)jenv; (void)jcls; - arg1 = *(SCIP_VAR ****)&jarg1; - arg2 = (int)jarg2; - arg3 = *(SCIP_VAR ***)&jarg3; - SCIP_VAR_array_array_setitem(arg1,arg2,arg3); + (void)jarg1_; + arg1 = *(SCIP_EventBdChg **)&jarg1; + arg2 = (double)jarg2; + if (arg1) (arg1)->oldbound = arg2; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1OKAY_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Retcode result; +SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventBdChg_1oldbound_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jdouble jresult = 0 ; + SCIP_EventBdChg *arg1 = (SCIP_EventBdChg *) 0 ; + double result; (void)jenv; (void)jcls; - result = (SCIP_Retcode)SCIP_OKAY; - jresult = (jint)result; + (void)jarg1_; + arg1 = *(SCIP_EventBdChg **)&jarg1; + result = (double) ((arg1)->oldbound); + jresult = (jdouble)result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1ERROR_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Retcode result; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventBdChg_1newbound_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) { + SCIP_EventBdChg *arg1 = (SCIP_EventBdChg *) 0 ; + double arg2 ; (void)jenv; (void)jcls; - result = (SCIP_Retcode)SCIP_ERROR; - jresult = (jint)result; - return jresult; + (void)jarg1_; + arg1 = *(SCIP_EventBdChg **)&jarg1; + arg2 = (double)jarg2; + if (arg1) (arg1)->newbound = arg2; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1NOMEMORY_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Retcode result; +SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventBdChg_1newbound_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jdouble jresult = 0 ; + SCIP_EventBdChg *arg1 = (SCIP_EventBdChg *) 0 ; + double result; (void)jenv; (void)jcls; - result = (SCIP_Retcode)SCIP_NOMEMORY; - jresult = (jint)result; + (void)jarg1_; + arg1 = *(SCIP_EventBdChg **)&jarg1; + result = (double) ((arg1)->newbound); + jresult = (jdouble)result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1READERROR_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Retcode result; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventBdChg_1var_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + SCIP_EventBdChg *arg1 = (SCIP_EventBdChg *) 0 ; + SCIP_VAR *arg2 = (SCIP_VAR *) 0 ; (void)jenv; (void)jcls; - result = (SCIP_Retcode)SCIP_READERROR; - jresult = (jint)result; - return jresult; + (void)jarg1_; + arg1 = *(SCIP_EventBdChg **)&jarg1; + arg2 = *(SCIP_VAR **)&jarg2; + if (arg1) (arg1)->var = arg2; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1WRITEERROR_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Retcode result; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventBdChg_1var_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SCIP_EventBdChg *arg1 = (SCIP_EventBdChg *) 0 ; + SCIP_VAR *result = 0 ; (void)jenv; (void)jcls; - result = (SCIP_Retcode)SCIP_WRITEERROR; - jresult = (jint)result; + (void)jarg1_; + arg1 = *(SCIP_EventBdChg **)&jarg1; + result = (SCIP_VAR *) ((arg1)->var); + *(SCIP_VAR **)&jresult = result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1NOFILE_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Retcode result; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_new_1SCIP_1EventBdChg(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + SCIP_EventBdChg *result = 0 ; (void)jenv; (void)jcls; - result = (SCIP_Retcode)SCIP_NOFILE; - jresult = (jint)result; + result = (SCIP_EventBdChg *)new SCIP_EventBdChg(); + *(SCIP_EventBdChg **)&jresult = result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1FILECREATEERROR_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Retcode result; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_delete_1SCIP_1EventBdChg(JNIEnv *jenv, jclass jcls, jlong jarg1) { + SCIP_EventBdChg *arg1 = (SCIP_EventBdChg *) 0 ; (void)jenv; (void)jcls; - result = (SCIP_Retcode)SCIP_FILECREATEERROR; - jresult = (jint)result; - return jresult; + arg1 = *(SCIP_EventBdChg **)&jarg1; + delete arg1; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1LPERROR_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Retcode result; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventHole_1left_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) { + SCIP_EventHole *arg1 = (SCIP_EventHole *) 0 ; + double arg2 ; (void)jenv; (void)jcls; - result = (SCIP_Retcode)SCIP_LPERROR; - jresult = (jint)result; - return jresult; + (void)jarg1_; + arg1 = *(SCIP_EventHole **)&jarg1; + arg2 = (double)jarg2; + if (arg1) (arg1)->left = arg2; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1NOPROBLEM_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Retcode result; +SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventHole_1left_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jdouble jresult = 0 ; + SCIP_EventHole *arg1 = (SCIP_EventHole *) 0 ; + double result; (void)jenv; (void)jcls; - result = (SCIP_Retcode)SCIP_NOPROBLEM; - jresult = (jint)result; + (void)jarg1_; + arg1 = *(SCIP_EventHole **)&jarg1; + result = (double) ((arg1)->left); + jresult = (jdouble)result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1INVALIDCALL_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Retcode result; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventHole_1right_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) { + SCIP_EventHole *arg1 = (SCIP_EventHole *) 0 ; + double arg2 ; (void)jenv; (void)jcls; - result = (SCIP_Retcode)SCIP_INVALIDCALL; - jresult = (jint)result; - return jresult; + (void)jarg1_; + arg1 = *(SCIP_EventHole **)&jarg1; + arg2 = (double)jarg2; + if (arg1) (arg1)->right = arg2; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1INVALIDDATA_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Retcode result; +SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventHole_1right_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jdouble jresult = 0 ; + SCIP_EventHole *arg1 = (SCIP_EventHole *) 0 ; + double result; (void)jenv; (void)jcls; - result = (SCIP_Retcode)SCIP_INVALIDDATA; - jresult = (jint)result; + (void)jarg1_; + arg1 = *(SCIP_EventHole **)&jarg1; + result = (double) ((arg1)->right); + jresult = (jdouble)result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1INVALIDRESULT_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Retcode result; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventHole_1var_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + SCIP_EventHole *arg1 = (SCIP_EventHole *) 0 ; + SCIP_VAR *arg2 = (SCIP_VAR *) 0 ; (void)jenv; (void)jcls; - result = (SCIP_Retcode)SCIP_INVALIDRESULT; - jresult = (jint)result; - return jresult; + (void)jarg1_; + arg1 = *(SCIP_EventHole **)&jarg1; + arg2 = *(SCIP_VAR **)&jarg2; + if (arg1) (arg1)->var = arg2; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1PLUGINNOTFOUND_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Retcode result; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventHole_1var_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SCIP_EventHole *arg1 = (SCIP_EventHole *) 0 ; + SCIP_VAR *result = 0 ; (void)jenv; (void)jcls; - result = (SCIP_Retcode)SCIP_PLUGINNOTFOUND; - jresult = (jint)result; + (void)jarg1_; + arg1 = *(SCIP_EventHole **)&jarg1; + result = (SCIP_VAR *) ((arg1)->var); + *(SCIP_VAR **)&jresult = result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1PARAMETERUNKNOWN_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Retcode result; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_new_1SCIP_1EventHole(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + SCIP_EventHole *result = 0 ; (void)jenv; (void)jcls; - result = (SCIP_Retcode)SCIP_PARAMETERUNKNOWN; - jresult = (jint)result; + result = (SCIP_EventHole *)new SCIP_EventHole(); + *(SCIP_EventHole **)&jresult = result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1PARAMETERWRONGTYPE_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Retcode result; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_delete_1SCIP_1EventHole(JNIEnv *jenv, jclass jcls, jlong jarg1) { + SCIP_EventHole *arg1 = (SCIP_EventHole *) 0 ; (void)jenv; (void)jcls; - result = (SCIP_Retcode)SCIP_PARAMETERWRONGTYPE; - jresult = (jint)result; - return jresult; + arg1 = *(SCIP_EventHole **)&jarg1; + delete arg1; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1PARAMETERWRONGVAL_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Retcode result; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventImplAdd_1var_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + SCIP_EventImplAdd *arg1 = (SCIP_EventImplAdd *) 0 ; + SCIP_VAR *arg2 = (SCIP_VAR *) 0 ; (void)jenv; (void)jcls; - result = (SCIP_Retcode)SCIP_PARAMETERWRONGVAL; - jresult = (jint)result; - return jresult; + (void)jarg1_; + arg1 = *(SCIP_EventImplAdd **)&jarg1; + arg2 = *(SCIP_VAR **)&jarg2; + if (arg1) (arg1)->var = arg2; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1KEYALREADYEXISTING_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Retcode result; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventImplAdd_1var_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SCIP_EventImplAdd *arg1 = (SCIP_EventImplAdd *) 0 ; + SCIP_VAR *result = 0 ; (void)jenv; (void)jcls; - result = (SCIP_Retcode)SCIP_KEYALREADYEXISTING; - jresult = (jint)result; + (void)jarg1_; + arg1 = *(SCIP_EventImplAdd **)&jarg1; + result = (SCIP_VAR *) ((arg1)->var); + *(SCIP_VAR **)&jresult = result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1MAXDEPTHLEVEL_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Retcode result; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_new_1SCIP_1EventImplAdd(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + SCIP_EventImplAdd *result = 0 ; (void)jenv; (void)jcls; - result = (SCIP_Retcode)SCIP_MAXDEPTHLEVEL; - jresult = (jint)result; + result = (SCIP_EventImplAdd *)new SCIP_EventImplAdd(); + *(SCIP_EventImplAdd **)&jresult = result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1BRANCHERROR_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Retcode result; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_delete_1SCIP_1EventImplAdd(JNIEnv *jenv, jclass jcls, jlong jarg1) { + SCIP_EventImplAdd *arg1 = (SCIP_EventImplAdd *) 0 ; (void)jenv; (void)jcls; - result = (SCIP_Retcode)SCIP_BRANCHERROR; - jresult = (jint)result; - return jresult; + arg1 = *(SCIP_EventImplAdd **)&jarg1; + delete arg1; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1VARTYPE_1BINARY_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Vartype result; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventTypeChg_1oldtype_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + SCIP_EventTypeChg *arg1 = (SCIP_EventTypeChg *) 0 ; + SCIP_VARTYPE arg2 ; (void)jenv; (void)jcls; - result = (SCIP_Vartype)SCIP_VARTYPE_BINARY; - jresult = (jint)result; - return jresult; + (void)jarg1_; + arg1 = *(SCIP_EventTypeChg **)&jarg1; + arg2 = (SCIP_VARTYPE)jarg2; + if (arg1) (arg1)->oldtype = arg2; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1VARTYPE_1INTEGER_1get(JNIEnv *jenv, jclass jcls) { +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventTypeChg_1oldtype_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jint jresult = 0 ; - SCIP_Vartype result; + SCIP_EventTypeChg *arg1 = (SCIP_EventTypeChg *) 0 ; + SCIP_VARTYPE result; (void)jenv; (void)jcls; - result = (SCIP_Vartype)SCIP_VARTYPE_INTEGER; + (void)jarg1_; + arg1 = *(SCIP_EventTypeChg **)&jarg1; + result = (SCIP_VARTYPE) ((arg1)->oldtype); jresult = (jint)result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1VARTYPE_1IMPLINT_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Vartype result; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventTypeChg_1newtype_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + SCIP_EventTypeChg *arg1 = (SCIP_EventTypeChg *) 0 ; + SCIP_VARTYPE arg2 ; (void)jenv; (void)jcls; - result = (SCIP_Vartype)SCIP_VARTYPE_IMPLINT; - jresult = (jint)result; - return jresult; + (void)jarg1_; + arg1 = *(SCIP_EventTypeChg **)&jarg1; + arg2 = (SCIP_VARTYPE)jarg2; + if (arg1) (arg1)->newtype = arg2; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1VARTYPE_1CONTINUOUS_1get(JNIEnv *jenv, jclass jcls) { +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventTypeChg_1newtype_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jint jresult = 0 ; - SCIP_Vartype result; + SCIP_EventTypeChg *arg1 = (SCIP_EventTypeChg *) 0 ; + SCIP_VARTYPE result; (void)jenv; (void)jcls; - result = (SCIP_Vartype)SCIP_VARTYPE_CONTINUOUS; + (void)jarg1_; + arg1 = *(SCIP_EventTypeChg **)&jarg1; + result = (SCIP_VARTYPE) ((arg1)->newtype); jresult = (jint)result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1BOUNDTYPE_1LOWER_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_BoundType result; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventTypeChg_1var_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + SCIP_EventTypeChg *arg1 = (SCIP_EventTypeChg *) 0 ; + SCIP_VAR *arg2 = (SCIP_VAR *) 0 ; (void)jenv; (void)jcls; - result = (SCIP_BoundType)SCIP_BOUNDTYPE_LOWER; - jresult = (jint)result; - return jresult; + (void)jarg1_; + arg1 = *(SCIP_EventTypeChg **)&jarg1; + arg2 = *(SCIP_VAR **)&jarg2; + if (arg1) (arg1)->var = arg2; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1BOUNDTYPE_1UPPER_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_BoundType result; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventTypeChg_1var_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SCIP_EventTypeChg *arg1 = (SCIP_EventTypeChg *) 0 ; + SCIP_VAR *result = 0 ; (void)jenv; (void)jcls; - result = (SCIP_BoundType)SCIP_BOUNDTYPE_UPPER; - jresult = (jint)result; + (void)jarg1_; + arg1 = *(SCIP_EventTypeChg **)&jarg1; + result = (SCIP_VAR *) ((arg1)->var); + *(SCIP_VAR **)&jresult = result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1ORBITOPETYPE_1FULL_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_OrbitopeType result; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_new_1SCIP_1EventTypeChg(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + SCIP_EventTypeChg *result = 0 ; (void)jenv; (void)jcls; - result = (SCIP_OrbitopeType)SCIP_ORBITOPETYPE_FULL; - jresult = (jint)result; + result = (SCIP_EventTypeChg *)new SCIP_EventTypeChg(); + *(SCIP_EventTypeChg **)&jresult = result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1ORBITOPETYPE_1PARTITIONING_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_OrbitopeType result; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_delete_1SCIP_1EventTypeChg(JNIEnv *jenv, jclass jcls, jlong jarg1) { + SCIP_EventTypeChg *arg1 = (SCIP_EventTypeChg *) 0 ; (void)jenv; (void)jcls; - result = (SCIP_OrbitopeType)SCIP_ORBITOPETYPE_PARTITIONING; - jresult = (jint)result; - return jresult; + arg1 = *(SCIP_EventTypeChg **)&jarg1; + delete arg1; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1ORBITOPETYPE_1PACKING_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_OrbitopeType result; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventRowAddedSepa_1row_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + SCIP_EventRowAddedSepa *arg1 = (SCIP_EventRowAddedSepa *) 0 ; + SCIP_ROW *arg2 = (SCIP_ROW *) 0 ; (void)jenv; (void)jcls; - result = (SCIP_OrbitopeType)SCIP_ORBITOPETYPE_PACKING; - jresult = (jint)result; - return jresult; + (void)jarg1_; + arg1 = *(SCIP_EventRowAddedSepa **)&jarg1; + arg2 = *(SCIP_ROW **)&jarg2; + if (arg1) (arg1)->row = arg2; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1PARAMSETTING_1DEFAULT_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_ParamSetting result; - +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventRowAddedSepa_1row_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SCIP_EventRowAddedSepa *arg1 = (SCIP_EventRowAddedSepa *) 0 ; + SCIP_ROW *result = 0 ; + (void)jenv; (void)jcls; - result = (SCIP_ParamSetting)SCIP_PARAMSETTING_DEFAULT; - jresult = (jint)result; + (void)jarg1_; + arg1 = *(SCIP_EventRowAddedSepa **)&jarg1; + result = (SCIP_ROW *) ((arg1)->row); + *(SCIP_ROW **)&jresult = result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1PARAMSETTING_1AGGRESSIVE_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_ParamSetting result; - +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_new_1SCIP_1EventRowAddedSepa(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + SCIP_EventRowAddedSepa *result = 0 ; + (void)jenv; (void)jcls; - result = (SCIP_ParamSetting)SCIP_PARAMSETTING_AGGRESSIVE; - jresult = (jint)result; + result = (SCIP_EventRowAddedSepa *)new SCIP_EventRowAddedSepa(); + *(SCIP_EventRowAddedSepa **)&jresult = result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1PARAMSETTING_1FAST_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_ParamSetting result; - +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_delete_1SCIP_1EventRowAddedSepa(JNIEnv *jenv, jclass jcls, jlong jarg1) { + SCIP_EventRowAddedSepa *arg1 = (SCIP_EventRowAddedSepa *) 0 ; + (void)jenv; (void)jcls; - result = (SCIP_ParamSetting)SCIP_PARAMSETTING_FAST; - jresult = (jint)result; - return jresult; + arg1 = *(SCIP_EventRowAddedSepa **)&jarg1; + delete arg1; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1PARAMSETTING_1OFF_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_ParamSetting result; - +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventRowDeletedSepa_1row_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + SCIP_EventRowDeletedSepa *arg1 = (SCIP_EventRowDeletedSepa *) 0 ; + SCIP_ROW *arg2 = (SCIP_ROW *) 0 ; + (void)jenv; (void)jcls; - result = (SCIP_ParamSetting)SCIP_PARAMSETTING_OFF; - jresult = (jint)result; - return jresult; + (void)jarg1_; + arg1 = *(SCIP_EventRowDeletedSepa **)&jarg1; + arg2 = *(SCIP_ROW **)&jarg2; + if (arg1) (arg1)->row = arg2; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1PARAMEMPHASIS_1DEFAULT_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_ParamEmphasis result; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventRowDeletedSepa_1row_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SCIP_EventRowDeletedSepa *arg1 = (SCIP_EventRowDeletedSepa *) 0 ; + SCIP_ROW *result = 0 ; (void)jenv; (void)jcls; - result = (SCIP_ParamEmphasis)SCIP_PARAMEMPHASIS_DEFAULT; - jresult = (jint)result; + (void)jarg1_; + arg1 = *(SCIP_EventRowDeletedSepa **)&jarg1; + result = (SCIP_ROW *) ((arg1)->row); + *(SCIP_ROW **)&jresult = result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1PARAMEMPHASIS_1CPSOLVER_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_ParamEmphasis result; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_new_1SCIP_1EventRowDeletedSepa(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + SCIP_EventRowDeletedSepa *result = 0 ; (void)jenv; (void)jcls; - result = (SCIP_ParamEmphasis)SCIP_PARAMEMPHASIS_CPSOLVER; - jresult = (jint)result; + result = (SCIP_EventRowDeletedSepa *)new SCIP_EventRowDeletedSepa(); + *(SCIP_EventRowDeletedSepa **)&jresult = result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1PARAMEMPHASIS_1EASYCIP_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_ParamEmphasis result; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_delete_1SCIP_1EventRowDeletedSepa(JNIEnv *jenv, jclass jcls, jlong jarg1) { + SCIP_EventRowDeletedSepa *arg1 = (SCIP_EventRowDeletedSepa *) 0 ; (void)jenv; (void)jcls; - result = (SCIP_ParamEmphasis)SCIP_PARAMEMPHASIS_EASYCIP; - jresult = (jint)result; - return jresult; + arg1 = *(SCIP_EventRowDeletedSepa **)&jarg1; + delete arg1; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1PARAMEMPHASIS_1FEASIBILITY_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_ParamEmphasis result; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventRowAddedLP_1row_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + SCIP_EventRowAddedLP *arg1 = (SCIP_EventRowAddedLP *) 0 ; + SCIP_ROW *arg2 = (SCIP_ROW *) 0 ; (void)jenv; (void)jcls; - result = (SCIP_ParamEmphasis)SCIP_PARAMEMPHASIS_FEASIBILITY; - jresult = (jint)result; - return jresult; + (void)jarg1_; + arg1 = *(SCIP_EventRowAddedLP **)&jarg1; + arg2 = *(SCIP_ROW **)&jarg2; + if (arg1) (arg1)->row = arg2; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1PARAMEMPHASIS_1HARDLP_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_ParamEmphasis result; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventRowAddedLP_1row_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SCIP_EventRowAddedLP *arg1 = (SCIP_EventRowAddedLP *) 0 ; + SCIP_ROW *result = 0 ; (void)jenv; (void)jcls; - result = (SCIP_ParamEmphasis)SCIP_PARAMEMPHASIS_HARDLP; - jresult = (jint)result; + (void)jarg1_; + arg1 = *(SCIP_EventRowAddedLP **)&jarg1; + result = (SCIP_ROW *) ((arg1)->row); + *(SCIP_ROW **)&jresult = result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1PARAMEMPHASIS_1OPTIMALITY_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_ParamEmphasis result; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_new_1SCIP_1EventRowAddedLP(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + SCIP_EventRowAddedLP *result = 0 ; (void)jenv; (void)jcls; - result = (SCIP_ParamEmphasis)SCIP_PARAMEMPHASIS_OPTIMALITY; - jresult = (jint)result; + result = (SCIP_EventRowAddedLP *)new SCIP_EventRowAddedLP(); + *(SCIP_EventRowAddedLP **)&jresult = result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1PARAMEMPHASIS_1COUNTER_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_ParamEmphasis result; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_delete_1SCIP_1EventRowAddedLP(JNIEnv *jenv, jclass jcls, jlong jarg1) { + SCIP_EventRowAddedLP *arg1 = (SCIP_EventRowAddedLP *) 0 ; (void)jenv; (void)jcls; - result = (SCIP_ParamEmphasis)SCIP_PARAMEMPHASIS_COUNTER; - jresult = (jint)result; - return jresult; + arg1 = *(SCIP_EventRowAddedLP **)&jarg1; + delete arg1; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1PARAMEMPHASIS_1PHASEFEAS_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_ParamEmphasis result; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventRowDeletedLP_1row_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + SCIP_EventRowDeletedLP *arg1 = (SCIP_EventRowDeletedLP *) 0 ; + SCIP_ROW *arg2 = (SCIP_ROW *) 0 ; (void)jenv; (void)jcls; - result = (SCIP_ParamEmphasis)SCIP_PARAMEMPHASIS_PHASEFEAS; - jresult = (jint)result; - return jresult; + (void)jarg1_; + arg1 = *(SCIP_EventRowDeletedLP **)&jarg1; + arg2 = *(SCIP_ROW **)&jarg2; + if (arg1) (arg1)->row = arg2; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1PARAMEMPHASIS_1PHASEIMPROVE_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_ParamEmphasis result; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventRowDeletedLP_1row_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SCIP_EventRowDeletedLP *arg1 = (SCIP_EventRowDeletedLP *) 0 ; + SCIP_ROW *result = 0 ; (void)jenv; (void)jcls; - result = (SCIP_ParamEmphasis)SCIP_PARAMEMPHASIS_PHASEIMPROVE; - jresult = (jint)result; + (void)jarg1_; + arg1 = *(SCIP_EventRowDeletedLP **)&jarg1; + result = (SCIP_ROW *) ((arg1)->row); + *(SCIP_ROW **)&jresult = result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1PARAMEMPHASIS_1PHASEPROOF_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_ParamEmphasis result; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_new_1SCIP_1EventRowDeletedLP(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + SCIP_EventRowDeletedLP *result = 0 ; (void)jenv; (void)jcls; - result = (SCIP_ParamEmphasis)SCIP_PARAMEMPHASIS_PHASEPROOF; - jresult = (jint)result; + result = (SCIP_EventRowDeletedLP *)new SCIP_EventRowDeletedLP(); + *(SCIP_EventRowDeletedLP **)&jresult = result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1VERBLEVEL_1NONE_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_VerbLevel result; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_delete_1SCIP_1EventRowDeletedLP(JNIEnv *jenv, jclass jcls, jlong jarg1) { + SCIP_EventRowDeletedLP *arg1 = (SCIP_EventRowDeletedLP *) 0 ; (void)jenv; (void)jcls; - result = (SCIP_VerbLevel)SCIP_VERBLEVEL_NONE; - jresult = (jint)result; - return jresult; + arg1 = *(SCIP_EventRowDeletedLP **)&jarg1; + delete arg1; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1VERBLEVEL_1DIALOG_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_VerbLevel result; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventRowCoefChanged_1row_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + SCIP_EventRowCoefChanged *arg1 = (SCIP_EventRowCoefChanged *) 0 ; + SCIP_ROW *arg2 = (SCIP_ROW *) 0 ; (void)jenv; (void)jcls; - result = (SCIP_VerbLevel)SCIP_VERBLEVEL_DIALOG; - jresult = (jint)result; - return jresult; + (void)jarg1_; + arg1 = *(SCIP_EventRowCoefChanged **)&jarg1; + arg2 = *(SCIP_ROW **)&jarg2; + if (arg1) (arg1)->row = arg2; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1VERBLEVEL_1MINIMAL_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_VerbLevel result; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventRowCoefChanged_1row_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SCIP_EventRowCoefChanged *arg1 = (SCIP_EventRowCoefChanged *) 0 ; + SCIP_ROW *result = 0 ; (void)jenv; (void)jcls; - result = (SCIP_VerbLevel)SCIP_VERBLEVEL_MINIMAL; - jresult = (jint)result; + (void)jarg1_; + arg1 = *(SCIP_EventRowCoefChanged **)&jarg1; + result = (SCIP_ROW *) ((arg1)->row); + *(SCIP_ROW **)&jresult = result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1VERBLEVEL_1NORMAL_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_VerbLevel result; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventRowCoefChanged_1col_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + SCIP_EventRowCoefChanged *arg1 = (SCIP_EventRowCoefChanged *) 0 ; + SCIP_COL *arg2 = (SCIP_COL *) 0 ; (void)jenv; (void)jcls; - result = (SCIP_VerbLevel)SCIP_VERBLEVEL_NORMAL; - jresult = (jint)result; - return jresult; + (void)jarg1_; + arg1 = *(SCIP_EventRowCoefChanged **)&jarg1; + arg2 = *(SCIP_COL **)&jarg2; + if (arg1) (arg1)->col = arg2; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1VERBLEVEL_1HIGH_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_VerbLevel result; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventRowCoefChanged_1col_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SCIP_EventRowCoefChanged *arg1 = (SCIP_EventRowCoefChanged *) 0 ; + SCIP_COL *result = 0 ; (void)jenv; (void)jcls; - result = (SCIP_VerbLevel)SCIP_VERBLEVEL_HIGH; - jresult = (jint)result; + (void)jarg1_; + arg1 = *(SCIP_EventRowCoefChanged **)&jarg1; + result = (SCIP_COL *) ((arg1)->col); + *(SCIP_COL **)&jresult = result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1VERBLEVEL_1FULL_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_VerbLevel result; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventRowCoefChanged_1oldval_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) { + SCIP_EventRowCoefChanged *arg1 = (SCIP_EventRowCoefChanged *) 0 ; + double arg2 ; (void)jenv; (void)jcls; - result = (SCIP_VerbLevel)SCIP_VERBLEVEL_FULL; - jresult = (jint)result; - return jresult; + (void)jarg1_; + arg1 = *(SCIP_EventRowCoefChanged **)&jarg1; + arg2 = (double)jarg2; + if (arg1) (arg1)->oldval = arg2; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1OBJSENSE_1MAXIMIZE_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Objsense result; +SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventRowCoefChanged_1oldval_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jdouble jresult = 0 ; + SCIP_EventRowCoefChanged *arg1 = (SCIP_EventRowCoefChanged *) 0 ; + double result; (void)jenv; (void)jcls; - result = (SCIP_Objsense)SCIP_OBJSENSE_MAXIMIZE; - jresult = (jint)result; + (void)jarg1_; + arg1 = *(SCIP_EventRowCoefChanged **)&jarg1; + result = (double) ((arg1)->oldval); + jresult = (jdouble)result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1OBJSENSE_1MINIMIZE_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Objsense result; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventRowCoefChanged_1newval_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) { + SCIP_EventRowCoefChanged *arg1 = (SCIP_EventRowCoefChanged *) 0 ; + double arg2 ; (void)jenv; (void)jcls; - result = (SCIP_Objsense)SCIP_OBJSENSE_MINIMIZE; - jresult = (jint)result; - return jresult; + (void)jarg1_; + arg1 = *(SCIP_EventRowCoefChanged **)&jarg1; + arg2 = (double)jarg2; + if (arg1) (arg1)->newval = arg2; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STATUS_1UNKNOWN_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Status result; +SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventRowCoefChanged_1newval_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jdouble jresult = 0 ; + SCIP_EventRowCoefChanged *arg1 = (SCIP_EventRowCoefChanged *) 0 ; + double result; (void)jenv; (void)jcls; - result = (SCIP_Status)SCIP_STATUS_UNKNOWN; - jresult = (jint)result; + (void)jarg1_; + arg1 = *(SCIP_EventRowCoefChanged **)&jarg1; + result = (double) ((arg1)->newval); + jresult = (jdouble)result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STATUS_1USERINTERRUPT_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Status result; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_new_1SCIP_1EventRowCoefChanged(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + SCIP_EventRowCoefChanged *result = 0 ; (void)jenv; (void)jcls; - result = (SCIP_Status)SCIP_STATUS_USERINTERRUPT; - jresult = (jint)result; + result = (SCIP_EventRowCoefChanged *)new SCIP_EventRowCoefChanged(); + *(SCIP_EventRowCoefChanged **)&jresult = result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STATUS_1NODELIMIT_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Status result; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_delete_1SCIP_1EventRowCoefChanged(JNIEnv *jenv, jclass jcls, jlong jarg1) { + SCIP_EventRowCoefChanged *arg1 = (SCIP_EventRowCoefChanged *) 0 ; (void)jenv; (void)jcls; - result = (SCIP_Status)SCIP_STATUS_NODELIMIT; - jresult = (jint)result; - return jresult; + arg1 = *(SCIP_EventRowCoefChanged **)&jarg1; + delete arg1; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STATUS_1TOTALNODELIMIT_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Status result; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventRowConstChanged_1row_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + SCIP_EventRowConstChanged *arg1 = (SCIP_EventRowConstChanged *) 0 ; + SCIP_ROW *arg2 = (SCIP_ROW *) 0 ; (void)jenv; (void)jcls; - result = (SCIP_Status)SCIP_STATUS_TOTALNODELIMIT; - jresult = (jint)result; - return jresult; + (void)jarg1_; + arg1 = *(SCIP_EventRowConstChanged **)&jarg1; + arg2 = *(SCIP_ROW **)&jarg2; + if (arg1) (arg1)->row = arg2; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STATUS_1STALLNODELIMIT_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Status result; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventRowConstChanged_1row_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SCIP_EventRowConstChanged *arg1 = (SCIP_EventRowConstChanged *) 0 ; + SCIP_ROW *result = 0 ; (void)jenv; (void)jcls; - result = (SCIP_Status)SCIP_STATUS_STALLNODELIMIT; - jresult = (jint)result; + (void)jarg1_; + arg1 = *(SCIP_EventRowConstChanged **)&jarg1; + result = (SCIP_ROW *) ((arg1)->row); + *(SCIP_ROW **)&jresult = result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STATUS_1TIMELIMIT_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Status result; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventRowConstChanged_1oldval_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) { + SCIP_EventRowConstChanged *arg1 = (SCIP_EventRowConstChanged *) 0 ; + double arg2 ; (void)jenv; (void)jcls; - result = (SCIP_Status)SCIP_STATUS_TIMELIMIT; - jresult = (jint)result; - return jresult; + (void)jarg1_; + arg1 = *(SCIP_EventRowConstChanged **)&jarg1; + arg2 = (double)jarg2; + if (arg1) (arg1)->oldval = arg2; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STATUS_1MEMLIMIT_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Status result; +SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventRowConstChanged_1oldval_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jdouble jresult = 0 ; + SCIP_EventRowConstChanged *arg1 = (SCIP_EventRowConstChanged *) 0 ; + double result; (void)jenv; (void)jcls; - result = (SCIP_Status)SCIP_STATUS_MEMLIMIT; - jresult = (jint)result; + (void)jarg1_; + arg1 = *(SCIP_EventRowConstChanged **)&jarg1; + result = (double) ((arg1)->oldval); + jresult = (jdouble)result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STATUS_1GAPLIMIT_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Status result; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventRowConstChanged_1newval_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) { + SCIP_EventRowConstChanged *arg1 = (SCIP_EventRowConstChanged *) 0 ; + double arg2 ; (void)jenv; (void)jcls; - result = (SCIP_Status)SCIP_STATUS_GAPLIMIT; - jresult = (jint)result; - return jresult; + (void)jarg1_; + arg1 = *(SCIP_EventRowConstChanged **)&jarg1; + arg2 = (double)jarg2; + if (arg1) (arg1)->newval = arg2; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STATUS_1SOLLIMIT_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Status result; +SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventRowConstChanged_1newval_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jdouble jresult = 0 ; + SCIP_EventRowConstChanged *arg1 = (SCIP_EventRowConstChanged *) 0 ; + double result; (void)jenv; (void)jcls; - result = (SCIP_Status)SCIP_STATUS_SOLLIMIT; - jresult = (jint)result; + (void)jarg1_; + arg1 = *(SCIP_EventRowConstChanged **)&jarg1; + result = (double) ((arg1)->newval); + jresult = (jdouble)result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STATUS_1BESTSOLLIMIT_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Status result; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_new_1SCIP_1EventRowConstChanged(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + SCIP_EventRowConstChanged *result = 0 ; (void)jenv; (void)jcls; - result = (SCIP_Status)SCIP_STATUS_BESTSOLLIMIT; - jresult = (jint)result; + result = (SCIP_EventRowConstChanged *)new SCIP_EventRowConstChanged(); + *(SCIP_EventRowConstChanged **)&jresult = result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STATUS_1RESTARTLIMIT_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Status result; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_delete_1SCIP_1EventRowConstChanged(JNIEnv *jenv, jclass jcls, jlong jarg1) { + SCIP_EventRowConstChanged *arg1 = (SCIP_EventRowConstChanged *) 0 ; (void)jenv; (void)jcls; - result = (SCIP_Status)SCIP_STATUS_RESTARTLIMIT; - jresult = (jint)result; - return jresult; + arg1 = *(SCIP_EventRowConstChanged **)&jarg1; + delete arg1; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STATUS_1OPTIMAL_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Status result; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventRowSideChanged_1row_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + SCIP_EventRowSideChanged *arg1 = (SCIP_EventRowSideChanged *) 0 ; + SCIP_ROW *arg2 = (SCIP_ROW *) 0 ; (void)jenv; (void)jcls; - result = (SCIP_Status)SCIP_STATUS_OPTIMAL; - jresult = (jint)result; - return jresult; + (void)jarg1_; + arg1 = *(SCIP_EventRowSideChanged **)&jarg1; + arg2 = *(SCIP_ROW **)&jarg2; + if (arg1) (arg1)->row = arg2; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STATUS_1INFEASIBLE_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Status result; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventRowSideChanged_1row_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SCIP_EventRowSideChanged *arg1 = (SCIP_EventRowSideChanged *) 0 ; + SCIP_ROW *result = 0 ; (void)jenv; (void)jcls; - result = (SCIP_Status)SCIP_STATUS_INFEASIBLE; - jresult = (jint)result; + (void)jarg1_; + arg1 = *(SCIP_EventRowSideChanged **)&jarg1; + result = (SCIP_ROW *) ((arg1)->row); + *(SCIP_ROW **)&jresult = result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STATUS_1UNBOUNDED_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Status result; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventRowSideChanged_1side_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + SCIP_EventRowSideChanged *arg1 = (SCIP_EventRowSideChanged *) 0 ; + SCIP_SIDETYPE arg2 ; + SCIP_SIDETYPE *argp2 ; (void)jenv; (void)jcls; - result = (SCIP_Status)SCIP_STATUS_UNBOUNDED; - jresult = (jint)result; - return jresult; + (void)jarg1_; + arg1 = *(SCIP_EventRowSideChanged **)&jarg1; + argp2 = *(SCIP_SIDETYPE **)&jarg2; + if (!argp2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null SCIP_SIDETYPE"); + return ; + } + arg2 = *argp2; + if (arg1) (arg1)->side = arg2; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STATUS_1INFORUNBD_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Status result; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventRowSideChanged_1side_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SCIP_EventRowSideChanged *arg1 = (SCIP_EventRowSideChanged *) 0 ; + SCIP_SIDETYPE result; (void)jenv; (void)jcls; - result = (SCIP_Status)SCIP_STATUS_INFORUNBD; - jresult = (jint)result; + (void)jarg1_; + arg1 = *(SCIP_EventRowSideChanged **)&jarg1; + result = ((arg1)->side); + *(SCIP_SIDETYPE **)&jresult = new SCIP_SIDETYPE((const SCIP_SIDETYPE &)result); return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STATUS_1TERMINATE_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Status result; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventRowSideChanged_1oldval_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) { + SCIP_EventRowSideChanged *arg1 = (SCIP_EventRowSideChanged *) 0 ; + double arg2 ; (void)jenv; (void)jcls; - result = (SCIP_Status)SCIP_STATUS_TERMINATE; - jresult = (jint)result; - return jresult; + (void)jarg1_; + arg1 = *(SCIP_EventRowSideChanged **)&jarg1; + arg2 = (double)jarg2; + if (arg1) (arg1)->oldval = arg2; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STAGE_1INIT_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Stage result; +SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventRowSideChanged_1oldval_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jdouble jresult = 0 ; + SCIP_EventRowSideChanged *arg1 = (SCIP_EventRowSideChanged *) 0 ; + double result; (void)jenv; (void)jcls; - result = (SCIP_Stage)SCIP_STAGE_INIT; - jresult = (jint)result; + (void)jarg1_; + arg1 = *(SCIP_EventRowSideChanged **)&jarg1; + result = (double) ((arg1)->oldval); + jresult = (jdouble)result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STAGE_1PROBLEM_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Stage result; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventRowSideChanged_1newval_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) { + SCIP_EventRowSideChanged *arg1 = (SCIP_EventRowSideChanged *) 0 ; + double arg2 ; (void)jenv; (void)jcls; - result = (SCIP_Stage)SCIP_STAGE_PROBLEM; - jresult = (jint)result; - return jresult; + (void)jarg1_; + arg1 = *(SCIP_EventRowSideChanged **)&jarg1; + arg2 = (double)jarg2; + if (arg1) (arg1)->newval = arg2; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STAGE_1TRANSFORMING_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Stage result; +SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIP_1EventRowSideChanged_1newval_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jdouble jresult = 0 ; + SCIP_EventRowSideChanged *arg1 = (SCIP_EventRowSideChanged *) 0 ; + double result; (void)jenv; (void)jcls; - result = (SCIP_Stage)SCIP_STAGE_TRANSFORMING; - jresult = (jint)result; + (void)jarg1_; + arg1 = *(SCIP_EventRowSideChanged **)&jarg1; + result = (double) ((arg1)->newval); + jresult = (jdouble)result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STAGE_1TRANSFORMED_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Stage result; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_new_1SCIP_1EventRowSideChanged(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + SCIP_EventRowSideChanged *result = 0 ; (void)jenv; (void)jcls; - result = (SCIP_Stage)SCIP_STAGE_TRANSFORMED; - jresult = (jint)result; + result = (SCIP_EventRowSideChanged *)new SCIP_EventRowSideChanged(); + *(SCIP_EventRowSideChanged **)&jresult = result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STAGE_1INITPRESOLVE_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Stage result; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_delete_1SCIP_1EventRowSideChanged(JNIEnv *jenv, jclass jcls, jlong jarg1) { + SCIP_EventRowSideChanged *arg1 = (SCIP_EventRowSideChanged *) 0 ; (void)jenv; (void)jcls; - result = (SCIP_Stage)SCIP_STAGE_INITPRESOLVE; - jresult = (jint)result; - return jresult; + arg1 = *(SCIP_EventRowSideChanged **)&jarg1; + delete arg1; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STAGE_1PRESOLVING_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Stage result; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIP_1Event_1eventtype_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + SCIP_Event *arg1 = (SCIP_Event *) 0 ; + SCIP_EVENTTYPE arg2 ; (void)jenv; (void)jcls; - result = (SCIP_Stage)SCIP_STAGE_PRESOLVING; - jresult = (jint)result; - return jresult; + (void)jarg1_; + arg1 = *(SCIP_Event **)&jarg1; + arg2 = (SCIP_EVENTTYPE)jarg2; + if (arg1) (arg1)->eventtype = arg2; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STAGE_1EXITPRESOLVE_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Stage result; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIP_1Event_1eventtype_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SCIP_Event *arg1 = (SCIP_Event *) 0 ; + SCIP_EVENTTYPE result; (void)jenv; (void)jcls; - result = (SCIP_Stage)SCIP_STAGE_EXITPRESOLVE; - jresult = (jint)result; + (void)jarg1_; + arg1 = *(SCIP_Event **)&jarg1; + result = (SCIP_EVENTTYPE) ((arg1)->eventtype); + jresult = (jlong)result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STAGE_1PRESOLVED_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Stage result; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_new_1SCIP_1Event(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + SCIP_Event *result = 0 ; (void)jenv; (void)jcls; - result = (SCIP_Stage)SCIP_STAGE_PRESOLVED; - jresult = (jint)result; + result = (SCIP_Event *)new SCIP_Event(); + *(SCIP_Event **)&jresult = result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STAGE_1INITSOLVE_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Stage result; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_delete_1SCIP_1Event(JNIEnv *jenv, jclass jcls, jlong jarg1) { + SCIP_Event *arg1 = (SCIP_Event *) 0 ; (void)jenv; (void)jcls; - result = (SCIP_Stage)SCIP_STAGE_INITSOLVE; - jresult = (jint)result; - return jresult; + arg1 = *(SCIP_Event **)&jarg1; + delete arg1; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STAGE_1SOLVING_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Stage result; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_getEventDataVarAdde(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SCIP_Event arg1 ; + SCIP_Event *argp1 ; + SCIP_EventVarAdded result; (void)jenv; (void)jcls; - result = (SCIP_Stage)SCIP_STAGE_SOLVING; - jresult = (jint)result; + (void)jarg1_; + argp1 = *(SCIP_Event **)&jarg1; + if (!argp1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null SCIP_Event"); + return 0; + } + arg1 = *argp1; + result = getEventDataVarAdde(arg1); + *(SCIP_EventVarAdded **)&jresult = new SCIP_EventVarAdded((const SCIP_EventVarAdded &)result); return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STAGE_1SOLVED_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Stage result; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_getEventDataVarDeleted(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SCIP_Event arg1 ; + SCIP_Event *argp1 ; + SCIP_EventVarDeleted result; (void)jenv; (void)jcls; - result = (SCIP_Stage)SCIP_STAGE_SOLVED; - jresult = (jint)result; + (void)jarg1_; + argp1 = *(SCIP_Event **)&jarg1; + if (!argp1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null SCIP_Event"); + return 0; + } + arg1 = *argp1; + result = getEventDataVarDeleted(arg1); + *(SCIP_EventVarDeleted **)&jresult = new SCIP_EventVarDeleted((const SCIP_EventVarDeleted &)result); return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STAGE_1EXITSOLVE_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Stage result; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_getEventDataVarFixed(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SCIP_Event arg1 ; + SCIP_Event *argp1 ; + SCIP_EventVarFixed result; (void)jenv; (void)jcls; - result = (SCIP_Stage)SCIP_STAGE_EXITSOLVE; - jresult = (jint)result; + (void)jarg1_; + argp1 = *(SCIP_Event **)&jarg1; + if (!argp1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null SCIP_Event"); + return 0; + } + arg1 = *argp1; + result = getEventDataVarFixed(arg1); + *(SCIP_EventVarFixed **)&jresult = new SCIP_EventVarFixed((const SCIP_EventVarFixed &)result); return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STAGE_1FREETRANS_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Stage result; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_getEventDataVarUnlocked(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SCIP_Event arg1 ; + SCIP_Event *argp1 ; + SCIP_EventVarUnlocked result; (void)jenv; (void)jcls; - result = (SCIP_Stage)SCIP_STAGE_FREETRANS; - jresult = (jint)result; + (void)jarg1_; + argp1 = *(SCIP_Event **)&jarg1; + if (!argp1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null SCIP_Event"); + return 0; + } + arg1 = *argp1; + result = getEventDataVarUnlocked(arg1); + *(SCIP_EventVarUnlocked **)&jresult = new SCIP_EventVarUnlocked((const SCIP_EventVarUnlocked &)result); return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1STAGE_1FREE_1get(JNIEnv *jenv, jclass jcls) { - jint jresult = 0 ; - SCIP_Stage result; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_getEventDataObjChg(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SCIP_Event arg1 ; + SCIP_Event *argp1 ; + SCIP_EventObjChg result; (void)jenv; (void)jcls; - result = (SCIP_Stage)SCIP_STAGE_FREE; - jresult = (jint)result; + (void)jarg1_; + argp1 = *(SCIP_Event **)&jarg1; + if (!argp1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null SCIP_Event"); + return 0; + } + arg1 = *argp1; + result = getEventDataObjChg(arg1); + *(SCIP_EventObjChg **)&jresult = new SCIP_EventObjChg((const SCIP_EventObjChg &)result); return jresult; } -SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIPcalcMachineEpsilon(JNIEnv *jenv, jclass jcls) { - jdouble jresult = 0 ; - double result; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_getEventDataBdChg(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SCIP_Event arg1 ; + SCIP_Event *argp1 ; + SCIP_EventBdChg result; (void)jenv; (void)jcls; - result = (double)SCIPcalcMachineEpsilon(); - jresult = (jdouble)result; + (void)jarg1_; + argp1 = *(SCIP_Event **)&jarg1; + if (!argp1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null SCIP_Event"); + return 0; + } + arg1 = *argp1; + result = getEventDataBdChg(arg1); + *(SCIP_EventBdChg **)&jresult = new SCIP_EventBdChg((const SCIP_EventBdChg &)result); return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPcreate(JNIEnv *jenv, jclass jcls, jlong jarg1) { - jint jresult = 0 ; - SCIP **arg1 = (SCIP **) 0 ; - SCIP_RETCODE result; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_getEventDataHole(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SCIP_Event arg1 ; + SCIP_Event *argp1 ; + SCIP_EventHole result; (void)jenv; (void)jcls; - arg1 = *(SCIP ***)&jarg1; - result = (SCIP_RETCODE)SCIPcreate(arg1); - jresult = (jint)result; + (void)jarg1_; + argp1 = *(SCIP_Event **)&jarg1; + if (!argp1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null SCIP_Event"); + return 0; + } + arg1 = *argp1; + result = getEventDataHole(arg1); + *(SCIP_EventHole **)&jresult = new SCIP_EventHole((const SCIP_EventHole &)result); return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPreadProb(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jstring jarg3) { - jint jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - char *arg2 = (char *) 0 ; - char *arg3 = (char *) 0 ; - SCIP_RETCODE result; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_getEventDataImplAdd(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SCIP_Event arg1 ; + SCIP_Event *argp1 ; + SCIP_EventImplAdd result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = 0; - if (jarg2) { - arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return 0; - } - arg3 = 0; - if (jarg3) { - arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0); - if (!arg3) return 0; + (void)jarg1_; + argp1 = *(SCIP_Event **)&jarg1; + if (!argp1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null SCIP_Event"); + return 0; } - result = (SCIP_RETCODE)SCIPreadProb(arg1,(char const *)arg2,(char const *)arg3); - jresult = (jint)result; - if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); - if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3); + arg1 = *argp1; + result = getEventDataImplAdd(arg1); + *(SCIP_EventImplAdd **)&jresult = new SCIP_EventImplAdd((const SCIP_EventImplAdd &)result); return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPreadParams(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2) { - jint jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - char *arg2 = (char *) 0 ; - SCIP_RETCODE result; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_getEventDataTypeChg(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SCIP_Event arg1 ; + SCIP_Event *argp1 ; + SCIP_EventTypeChg result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = 0; - if (jarg2) { - arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return 0; + (void)jarg1_; + argp1 = *(SCIP_Event **)&jarg1; + if (!argp1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null SCIP_Event"); + return 0; } - result = (SCIP_RETCODE)SCIPreadParams(arg1,(char const *)arg2); - jresult = (jint)result; - if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + arg1 = *argp1; + result = getEventDataTypeChg(arg1); + *(SCIP_EventTypeChg **)&jresult = new SCIP_EventTypeChg((const SCIP_EventTypeChg &)result); return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPcreateProbBasic(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2) { - jint jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - char *arg2 = (char *) 0 ; - SCIP_RETCODE result; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_getEventDataRowAddedSepa(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SCIP_Event arg1 ; + SCIP_Event *argp1 ; + SCIP_EventRowAddedSepa result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = 0; - if (jarg2) { - arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return 0; + (void)jarg1_; + argp1 = *(SCIP_Event **)&jarg1; + if (!argp1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null SCIP_Event"); + return 0; } - result = (SCIP_RETCODE)SCIPcreateProbBasic(arg1,(char const *)arg2); - jresult = (jint)result; - if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + arg1 = *argp1; + result = getEventDataRowAddedSepa(arg1); + *(SCIP_EventRowAddedSepa **)&jresult = new SCIP_EventRowAddedSepa((const SCIP_EventRowAddedSepa &)result); return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPincludeDefaultPlugins(JNIEnv *jenv, jclass jcls, jlong jarg1) { - jint jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - SCIP_RETCODE result; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_getEventDataRowDeletedSepa(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SCIP_Event arg1 ; + SCIP_Event *argp1 ; + SCIP_EventRowDeletedSepa result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - result = (SCIP_RETCODE)SCIPincludeDefaultPlugins(arg1); - jresult = (jint)result; + (void)jarg1_; + argp1 = *(SCIP_Event **)&jarg1; + if (!argp1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null SCIP_Event"); + return 0; + } + arg1 = *argp1; + result = getEventDataRowDeletedSepa(arg1); + *(SCIP_EventRowDeletedSepa **)&jresult = new SCIP_EventRowDeletedSepa((const SCIP_EventRowDeletedSepa &)result); return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPsolve(JNIEnv *jenv, jclass jcls, jlong jarg1) { - jint jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - SCIP_RETCODE result; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_getEventDataRowAddedLp(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SCIP_Event arg1 ; + SCIP_Event *argp1 ; + SCIP_EventRowAddedLP result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - result = (SCIP_RETCODE)SCIPsolve(arg1); - jresult = (jint)result; + (void)jarg1_; + argp1 = *(SCIP_Event **)&jarg1; + if (!argp1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null SCIP_Event"); + return 0; + } + arg1 = *argp1; + result = getEventDataRowAddedLp(arg1); + *(SCIP_EventRowAddedLP **)&jresult = new SCIP_EventRowAddedLP((const SCIP_EventRowAddedLP &)result); return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPsolveConcurrent(JNIEnv *jenv, jclass jcls, jlong jarg1) { - jint jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - SCIP_RETCODE result; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_getEventDataRowDeletedLp(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SCIP_Event arg1 ; + SCIP_Event *argp1 ; + SCIP_EventRowDeletedLP result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - result = (SCIP_RETCODE)SCIPsolveConcurrent(arg1); - jresult = (jint)result; + (void)jarg1_; + argp1 = *(SCIP_Event **)&jarg1; + if (!argp1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null SCIP_Event"); + return 0; + } + arg1 = *argp1; + result = getEventDataRowDeletedLp(arg1); + *(SCIP_EventRowDeletedLP **)&jresult = new SCIP_EventRowDeletedLP((const SCIP_EventRowDeletedLP &)result); return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPinterruptSolve(JNIEnv *jenv, jclass jcls, jlong jarg1) { - jint jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - SCIP_RETCODE result; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_getEventDataRowCoefChanged(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SCIP_Event arg1 ; + SCIP_Event *argp1 ; + SCIP_EventRowCoefChanged result; - (void)jenv; - (void)jcls; - arg1 = *(SCIP **)&jarg1; - result = (SCIP_RETCODE)SCIPinterruptSolve(arg1); - jresult = (jint)result; + (void)jenv; + (void)jcls; + (void)jarg1_; + argp1 = *(SCIP_Event **)&jarg1; + if (!argp1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null SCIP_Event"); + return 0; + } + arg1 = *argp1; + result = getEventDataRowCoefChanged(arg1); + *(SCIP_EventRowCoefChanged **)&jresult = new SCIP_EventRowCoefChanged((const SCIP_EventRowCoefChanged &)result); return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIPisSolveInterrupted(JNIEnv *jenv, jclass jcls, jlong jarg1) { +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_getEventDataRowConstChanged(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - unsigned int result; + SCIP_Event arg1 ; + SCIP_Event *argp1 ; + SCIP_EventRowConstChanged result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - result = (unsigned int)SCIPisSolveInterrupted(arg1); - jresult = (jlong)result; + (void)jarg1_; + argp1 = *(SCIP_Event **)&jarg1; + if (!argp1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null SCIP_Event"); + return 0; + } + arg1 = *argp1; + result = getEventDataRowConstChanged(arg1); + *(SCIP_EventRowConstChanged **)&jresult = new SCIP_EventRowConstChanged((const SCIP_EventRowConstChanged &)result); return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPaddVar(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { - jint jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - SCIP_VAR *arg2 = (SCIP_VAR *) 0 ; - SCIP_RETCODE result; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_getEventDataRowSideChanged(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SCIP_Event arg1 ; + SCIP_Event *argp1 ; + SCIP_EventRowSideChanged result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = *(SCIP_VAR **)&jarg2; - result = (SCIP_RETCODE)SCIPaddVar(arg1,arg2); - jresult = (jint)result; + (void)jarg1_; + argp1 = *(SCIP_Event **)&jarg1; + if (!argp1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null SCIP_Event"); + return 0; + } + arg1 = *argp1; + result = getEventDataRowSideChanged(arg1); + *(SCIP_EventRowSideChanged **)&jresult = new SCIP_EventRowSideChanged((const SCIP_EventRowSideChanged &)result); return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPgetNVars(JNIEnv *jenv, jclass jcls, jlong jarg1) { - jint jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - int result; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_getEventDataSolution(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SCIP_Event arg1 ; + SCIP_Event *argp1 ; + SCIP_SOL *result = 0 ; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - result = (int)SCIPgetNVars(arg1); - jresult = (jint)result; + (void)jarg1_; + argp1 = *(SCIP_Event **)&jarg1; + if (!argp1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null SCIP_Event"); + return 0; + } + arg1 = *argp1; + result = (SCIP_SOL *)getEventDataSolution(arg1); + *(SCIP_SOL **)&jresult = result; return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIPgetVars(JNIEnv *jenv, jclass jcls, jlong jarg1) { +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_getEventDataNode(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - SCIP_VAR **result = 0 ; + SCIP_Event arg1 ; + SCIP_Event *argp1 ; + SCIP_NODE *result = 0 ; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - result = (SCIP_VAR **)SCIPgetVars(arg1); - *(SCIP_VAR ***)&jresult = result; + (void)jarg1_; + argp1 = *(SCIP_Event **)&jarg1; + if (!argp1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null SCIP_Event"); + return 0; + } + arg1 = *argp1; + result = (SCIP_NODE *)getEventDataNode(arg1); + *(SCIP_NODE **)&jresult = result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPgetNOrigVars(JNIEnv *jenv, jclass jcls, jlong jarg1) { - jint jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - int result; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_ObjEventhdlr_1scip_1_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + scip::ObjEventhdlr *arg1 = (scip::ObjEventhdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - result = (int)SCIPgetNOrigVars(arg1); - jresult = (jint)result; - return jresult; + (void)jarg1_; + arg1 = *(scip::ObjEventhdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + if (arg1) (arg1)->scip_ = arg2; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIPgetOrigVars(JNIEnv *jenv, jclass jcls, jlong jarg1) { +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_ObjEventhdlr_1scip_1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - SCIP_VAR **result = 0 ; + scip::ObjEventhdlr *arg1 = (scip::ObjEventhdlr *) 0 ; + SCIP *result = 0 ; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - result = (SCIP_VAR **)SCIPgetOrigVars(arg1); - *(SCIP_VAR ***)&jresult = result; + (void)jarg1_; + arg1 = *(scip::ObjEventhdlr **)&jarg1; + result = (SCIP *) ((arg1)->scip_); + *(SCIP **)&jresult = result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPaddCons(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { - jint jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - SCIP_CONS *arg2 = (SCIP_CONS *) 0 ; - SCIP_RETCODE result; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_ObjEventhdlr_1scip_1name_1_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + scip::ObjEventhdlr *arg1 = (scip::ObjEventhdlr *) 0 ; + char *arg2 = (char *) 0 ; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = *(SCIP_CONS **)&jarg2; - result = (SCIP_RETCODE)SCIPaddCons(arg1,arg2); - jresult = (jint)result; + (void)jarg1_; + arg1 = *(scip::ObjEventhdlr **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return ; + } + { + delete [] arg1->scip_name_; + if (arg2) { + arg1->scip_name_ = (char *) (new char[strlen((const char *)arg2)+1]); + strcpy((char *)arg1->scip_name_, (const char *)arg2); + } else { + arg1->scip_name_ = 0; + } + } + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); +} + + +SWIGEXPORT jstring JNICALL Java_jscip_SCIPJNIJNI_ObjEventhdlr_1scip_1name_1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + scip::ObjEventhdlr *arg1 = (scip::ObjEventhdlr *) 0 ; + char *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(scip::ObjEventhdlr **)&jarg1; + result = (char *) ((arg1)->scip_name_); + if (result) jresult = jenv->NewStringUTF((const char *)result); return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPwriteOrigProblem(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jstring jarg3, jlong jarg4) { - jint jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_ObjEventhdlr_1scip_1desc_1_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + scip::ObjEventhdlr *arg1 = (scip::ObjEventhdlr *) 0 ; char *arg2 = (char *) 0 ; - char *arg3 = (char *) 0 ; - unsigned int arg4 ; - SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; + (void)jarg1_; + arg1 = *(scip::ObjEventhdlr **)&jarg1; arg2 = 0; if (jarg2) { arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return 0; + if (!arg2) return ; } - arg3 = 0; - if (jarg3) { - arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0); - if (!arg3) return 0; + { + delete [] arg1->scip_desc_; + if (arg2) { + arg1->scip_desc_ = (char *) (new char[strlen((const char *)arg2)+1]); + strcpy((char *)arg1->scip_desc_, (const char *)arg2); + } else { + arg1->scip_desc_ = 0; + } } - arg4 = (unsigned int)jarg4; - result = (SCIP_RETCODE)SCIPwriteOrigProblem(arg1,(char const *)arg2,(char const *)arg3,arg4); - jresult = (jint)result; if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); - if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3); +} + + +SWIGEXPORT jstring JNICALL Java_jscip_SCIPJNIJNI_ObjEventhdlr_1scip_1desc_1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + scip::ObjEventhdlr *arg1 = (scip::ObjEventhdlr *) 0 ; + char *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(scip::ObjEventhdlr **)&jarg1; + result = (char *) ((arg1)->scip_desc_); + if (result) jresult = jenv->NewStringUTF((const char *)result); return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPwriteTransProblem(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jstring jarg3, jlong jarg4) { - jint jresult = 0 ; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_new_1ObjEventhdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jstring jarg3) { + jlong jresult = 0 ; SCIP *arg1 = (SCIP *) 0 ; char *arg2 = (char *) 0 ; char *arg3 = (char *) 0 ; - unsigned int arg4 ; - SCIP_RETCODE result; + scip::ObjEventhdlr *result = 0 ; (void)jenv; (void)jcls; @@ -3634,375 +9785,346 @@ SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPwriteTransProblem(JNIEnv *jenv arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0); if (!arg3) return 0; } - arg4 = (unsigned int)jarg4; - result = (SCIP_RETCODE)SCIPwriteTransProblem(arg1,(char const *)arg2,(char const *)arg3,arg4); - jresult = (jint)result; + result = (scip::ObjEventhdlr *)new SwigDirector_ObjEventhdlr(jenv,arg1,(char const *)arg2,(char const *)arg3); + *(scip::ObjEventhdlr **)&jresult = result; if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3); return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPprintStatistics(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { - jint jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - FILE *arg2 = (FILE *) 0 ; - SCIP_RETCODE result; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_delete_1ObjEventhdlr(JNIEnv *jenv, jclass jcls, jlong jarg1) { + scip::ObjEventhdlr *arg1 = (scip::ObjEventhdlr *) 0 ; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = *(FILE **)&jarg2; - result = (SCIP_RETCODE)SCIPprintStatistics(arg1,arg2); - jresult = (jint)result; - return jresult; + arg1 = *(scip::ObjEventhdlr **)&jarg1; + delete arg1; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPprintBestSol(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjEventhdlr_1scip_1free(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3) { jint jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - FILE *arg2 = (FILE *) 0 ; - unsigned int arg3 ; + scip::ObjEventhdlr *arg1 = (scip::ObjEventhdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_EVENTHDLR *arg3 = (SCIP_EVENTHDLR *) 0 ; SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = *(FILE **)&jarg2; - arg3 = (unsigned int)jarg3; - result = (SCIP_RETCODE)SCIPprintBestSol(arg1,arg2,arg3); + (void)jarg1_; + arg1 = *(scip::ObjEventhdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_EVENTHDLR **)&jarg3; + result = (SCIP_RETCODE)(arg1)->scip_free(arg2,arg3); jresult = (jint)result; return jresult; } -SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIPsetMessagehdlrQuiet(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { - SCIP *arg1 = (SCIP *) 0 ; - unsigned int arg2 ; - - (void)jenv; - (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = (unsigned int)jarg2; - SCIPsetMessagehdlrQuiet(arg1,arg2); -} - - -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPgetStatus(JNIEnv *jenv, jclass jcls, jlong jarg1) { +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjEventhdlr_1scip_1freeSwigExplicitObjEventhdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3) { jint jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - SCIP_STATUS result; + scip::ObjEventhdlr *arg1 = (scip::ObjEventhdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_EVENTHDLR *arg3 = (SCIP_EVENTHDLR *) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - result = (SCIP_STATUS)SCIPgetStatus(arg1); + (void)jarg1_; + arg1 = *(scip::ObjEventhdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_EVENTHDLR **)&jarg3; + result = (SCIP_RETCODE)(arg1)->scip::ObjEventhdlr::scip_free(arg2,arg3); jresult = (jint)result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPgetStage(JNIEnv *jenv, jclass jcls, jlong jarg1) { +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjEventhdlr_1scip_1init(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3) { jint jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - SCIP_STAGE result; + scip::ObjEventhdlr *arg1 = (scip::ObjEventhdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_EVENTHDLR *arg3 = (SCIP_EVENTHDLR *) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - result = (SCIP_STAGE)SCIPgetStage(arg1); + (void)jarg1_; + arg1 = *(scip::ObjEventhdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_EVENTHDLR **)&jarg3; + result = (SCIP_RETCODE)(arg1)->scip_init(arg2,arg3); jresult = (jint)result; return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIPgetSols(JNIEnv *jenv, jclass jcls, jlong jarg1) { - jlong jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - SCIP_SOL **result = 0 ; - - (void)jenv; - (void)jcls; - arg1 = *(SCIP **)&jarg1; - result = (SCIP_SOL **)SCIPgetSols(arg1); - *(SCIP_SOL ***)&jresult = result; - return jresult; -} - - -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPgetNSols(JNIEnv *jenv, jclass jcls, jlong jarg1) { +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjEventhdlr_1scip_1initSwigExplicitObjEventhdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3) { jint jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - int result; + scip::ObjEventhdlr *arg1 = (scip::ObjEventhdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_EVENTHDLR *arg3 = (SCIP_EVENTHDLR *) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - result = (int)SCIPgetNSols(arg1); + (void)jarg1_; + arg1 = *(scip::ObjEventhdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_EVENTHDLR **)&jarg3; + result = (SCIP_RETCODE)(arg1)->scip::ObjEventhdlr::scip_init(arg2,arg3); jresult = (jint)result; return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIPgetBestSol(JNIEnv *jenv, jclass jcls, jlong jarg1) { - jlong jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - SCIP_SOL *result = 0 ; - - (void)jenv; - (void)jcls; - arg1 = *(SCIP **)&jarg1; - result = (SCIP_SOL *)SCIPgetBestSol(arg1); - *(SCIP_SOL **)&jresult = result; - return jresult; -} - - -SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIPgetSolVal(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { - jdouble jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - SCIP_SOL *arg2 = (SCIP_SOL *) 0 ; - SCIP_VAR *arg3 = (SCIP_VAR *) 0 ; - double result; - - (void)jenv; - (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = *(SCIP_SOL **)&jarg2; - arg3 = *(SCIP_VAR **)&jarg3; - result = (double)SCIPgetSolVal(arg1,arg2,arg3); - jresult = (jdouble)result; - return jresult; -} - - -SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIPgetSolOrigObj(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { - jdouble jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - SCIP_SOL *arg2 = (SCIP_SOL *) 0 ; - double result; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjEventhdlr_1scip_1exit(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3) { + jint jresult = 0 ; + scip::ObjEventhdlr *arg1 = (scip::ObjEventhdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_EVENTHDLR *arg3 = (SCIP_EVENTHDLR *) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = *(SCIP_SOL **)&jarg2; - result = (double)SCIPgetSolOrigObj(arg1,arg2); - jresult = (jdouble)result; + (void)jarg1_; + arg1 = *(scip::ObjEventhdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_EVENTHDLR **)&jarg3; + result = (SCIP_RETCODE)(arg1)->scip_exit(arg2,arg3); + jresult = (jint)result; return jresult; } -SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIPinfinity(JNIEnv *jenv, jclass jcls, jlong jarg1) { - jdouble jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - double result; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjEventhdlr_1scip_1exitSwigExplicitObjEventhdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3) { + jint jresult = 0 ; + scip::ObjEventhdlr *arg1 = (scip::ObjEventhdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_EVENTHDLR *arg3 = (SCIP_EVENTHDLR *) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - result = (double)SCIPinfinity(arg1); - jresult = (jdouble)result; + (void)jarg1_; + arg1 = *(scip::ObjEventhdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_EVENTHDLR **)&jarg3; + result = (SCIP_RETCODE)(arg1)->scip::ObjEventhdlr::scip_exit(arg2,arg3); + jresult = (jint)result; return jresult; } - -SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIPepsilon(JNIEnv *jenv, jclass jcls, jlong jarg1) { - jdouble jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - double result; + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjEventhdlr_1scip_1initsol(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3) { + jint jresult = 0 ; + scip::ObjEventhdlr *arg1 = (scip::ObjEventhdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_EVENTHDLR *arg3 = (SCIP_EVENTHDLR *) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - result = (double)SCIPepsilon(arg1); - jresult = (jdouble)result; + (void)jarg1_; + arg1 = *(scip::ObjEventhdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_EVENTHDLR **)&jarg3; + result = (SCIP_RETCODE)(arg1)->scip_initsol(arg2,arg3); + jresult = (jint)result; return jresult; } -SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIPfeastol(JNIEnv *jenv, jclass jcls, jlong jarg1) { - jdouble jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - double result; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjEventhdlr_1scip_1initsolSwigExplicitObjEventhdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3) { + jint jresult = 0 ; + scip::ObjEventhdlr *arg1 = (scip::ObjEventhdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_EVENTHDLR *arg3 = (SCIP_EVENTHDLR *) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - result = (double)SCIPfeastol(arg1); - jresult = (jdouble)result; + (void)jarg1_; + arg1 = *(scip::ObjEventhdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_EVENTHDLR **)&jarg3; + result = (SCIP_RETCODE)(arg1)->scip::ObjEventhdlr::scip_initsol(arg2,arg3); + jresult = (jint)result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPgetBoolParam(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3) { +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjEventhdlr_1scip_1exitsol(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3) { jint jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - char *arg2 = (char *) 0 ; - unsigned int *arg3 = (unsigned int *) 0 ; + scip::ObjEventhdlr *arg1 = (scip::ObjEventhdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_EVENTHDLR *arg3 = (SCIP_EVENTHDLR *) 0 ; SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = 0; - if (jarg2) { - arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return 0; - } - arg3 = *(unsigned int **)&jarg3; - result = (SCIP_RETCODE)SCIPgetBoolParam(arg1,(char const *)arg2,arg3); + (void)jarg1_; + arg1 = *(scip::ObjEventhdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_EVENTHDLR **)&jarg3; + result = (SCIP_RETCODE)(arg1)->scip_exitsol(arg2,arg3); jresult = (jint)result; - if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPgetIntParam(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3) { +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjEventhdlr_1scip_1exitsolSwigExplicitObjEventhdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3) { jint jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - char *arg2 = (char *) 0 ; - int *arg3 = (int *) 0 ; + scip::ObjEventhdlr *arg1 = (scip::ObjEventhdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_EVENTHDLR *arg3 = (SCIP_EVENTHDLR *) 0 ; SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = 0; - if (jarg2) { - arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return 0; - } - arg3 = *(int **)&jarg3; - result = (SCIP_RETCODE)SCIPgetIntParam(arg1,(char const *)arg2,arg3); + (void)jarg1_; + arg1 = *(scip::ObjEventhdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_EVENTHDLR **)&jarg3; + result = (SCIP_RETCODE)(arg1)->scip::ObjEventhdlr::scip_exitsol(arg2,arg3); jresult = (jint)result; - if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPgetLongintParam(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3) { +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjEventhdlr_1scip_1delete(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4) { jint jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - char *arg2 = (char *) 0 ; - long long *arg3 = (long long *) 0 ; + scip::ObjEventhdlr *arg1 = (scip::ObjEventhdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_EVENTHDLR *arg3 = (SCIP_EVENTHDLR *) 0 ; + SCIP_EVENTDATA **arg4 = (SCIP_EVENTDATA **) 0 ; SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = 0; - if (jarg2) { - arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return 0; - } - arg3 = *(long long **)&jarg3; - result = (SCIP_RETCODE)SCIPgetLongintParam(arg1,(char const *)arg2,arg3); + (void)jarg1_; + arg1 = *(scip::ObjEventhdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_EVENTHDLR **)&jarg3; + arg4 = *(SCIP_EVENTDATA ***)&jarg4; + result = (SCIP_RETCODE)(arg1)->scip_delete(arg2,arg3,arg4); jresult = (jint)result; - if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPgetRealParam(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3) { +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjEventhdlr_1scip_1deleteSwigExplicitObjEventhdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4) { jint jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - char *arg2 = (char *) 0 ; - double *arg3 = (double *) 0 ; + scip::ObjEventhdlr *arg1 = (scip::ObjEventhdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_EVENTHDLR *arg3 = (SCIP_EVENTHDLR *) 0 ; + SCIP_EVENTDATA **arg4 = (SCIP_EVENTDATA **) 0 ; SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = 0; - if (jarg2) { - arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return 0; - } - arg3 = *(double **)&jarg3; - result = (SCIP_RETCODE)SCIPgetRealParam(arg1,(char const *)arg2,arg3); + (void)jarg1_; + arg1 = *(scip::ObjEventhdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_EVENTHDLR **)&jarg3; + arg4 = *(SCIP_EVENTDATA ***)&jarg4; + result = (SCIP_RETCODE)(arg1)->scip::ObjEventhdlr::scip_delete(arg2,arg3,arg4); jresult = (jint)result; - if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPgetCharParam(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3) { +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjEventhdlr_1scip_1exec(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jobject jarg4_, jlong jarg5) { jint jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - char *arg2 = (char *) 0 ; - char *arg3 = (char *) 0 ; + scip::ObjEventhdlr *arg1 = (scip::ObjEventhdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_EVENTHDLR *arg3 = (SCIP_EVENTHDLR *) 0 ; + SCIP_Event *arg4 = (SCIP_Event *) 0 ; + SCIP_EVENTDATA *arg5 = (SCIP_EVENTDATA *) 0 ; SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = 0; - if (jarg2) { - arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return 0; - } - arg3 = *(char **)&jarg3; - result = (SCIP_RETCODE)SCIPgetCharParam(arg1,(char const *)arg2,arg3); + (void)jarg1_; + (void)jarg4_; + arg1 = *(scip::ObjEventhdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_EVENTHDLR **)&jarg3; + arg4 = *(SCIP_Event **)&jarg4; + arg5 = *(SCIP_EVENTDATA **)&jarg5; + result = (SCIP_RETCODE)(arg1)->scip_exec(arg2,arg3,arg4,arg5); jresult = (jint)result; - if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); - return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPgetStringParam(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3) { +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjEventhdlr_1scip_1execSwigExplicitObjEventhdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jobject jarg4_, jlong jarg5) { jint jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - char *arg2 = (char *) 0 ; - char **arg3 = (char **) 0 ; + scip::ObjEventhdlr *arg1 = (scip::ObjEventhdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_EVENTHDLR *arg3 = (SCIP_EVENTHDLR *) 0 ; + SCIP_Event *arg4 = (SCIP_Event *) 0 ; + SCIP_EVENTDATA *arg5 = (SCIP_EVENTDATA *) 0 ; SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = 0; - if (jarg2) { - arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return 0; - } - arg3 = *(char ***)&jarg3; - result = (SCIP_RETCODE)SCIPgetStringParam(arg1,(char const *)arg2,arg3); + (void)jarg1_; + (void)jarg4_; + arg1 = *(scip::ObjEventhdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_EVENTHDLR **)&jarg3; + arg4 = *(SCIP_Event **)&jarg4; + arg5 = *(SCIP_EVENTDATA **)&jarg5; + result = (SCIP_RETCODE)(arg1)->scip::ObjEventhdlr::scip_exec(arg2,arg3,arg4,arg5); jresult = (jint)result; - if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPsetBoolParam(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3) { +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_ObjEventhdlr_1director_1connect(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jswig_mem_own, jboolean jweak_global) { + scip::ObjEventhdlr *obj = *((scip::ObjEventhdlr **)&objarg); + (void)jcls; + SwigDirector_ObjEventhdlr *director = static_cast(obj); + director->swig_connect_director(jenv, jself, jenv->GetObjectClass(jself), (jswig_mem_own == JNI_TRUE), (jweak_global == JNI_TRUE)); +} + + +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_ObjEventhdlr_1change_1ownership(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jtake_or_release) { + scip::ObjEventhdlr *obj = *((scip::ObjEventhdlr **)&objarg); + SwigDirector_ObjEventhdlr *director = dynamic_cast(obj); + (void)jcls; + if (director) { + director->swig_java_change_ownership(jenv, jself, jtake_or_release ? true : false); + } +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPincludeObjEventhdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jobject jarg2_, jlong jarg3) { jint jresult = 0 ; SCIP *arg1 = (SCIP *) 0 ; - char *arg2 = (char *) 0 ; + scip::ObjEventhdlr *arg2 = (scip::ObjEventhdlr *) 0 ; unsigned int arg3 ; SCIP_RETCODE result; (void)jenv; (void)jcls; + (void)jarg2_; arg1 = *(SCIP **)&jarg1; - arg2 = 0; - if (jarg2) { - arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return 0; - } + arg2 = *(scip::ObjEventhdlr **)&jarg2; arg3 = (unsigned int)jarg3; - result = (SCIP_RETCODE)SCIPsetBoolParam(arg1,(char const *)arg2,arg3); + result = (SCIP_RETCODE)SCIPincludeObjEventhdlr(arg1,arg2,arg3); jresult = (jint)result; - if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPsetIntParam(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jint jarg3) { - jint jresult = 0 ; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIPfindObjEventhdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2) { + jlong jresult = 0 ; SCIP *arg1 = (SCIP *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; - SCIP_RETCODE result; + scip::ObjEventhdlr *result = 0 ; (void)jenv; (void)jcls; @@ -4012,2057 +10134,2589 @@ SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPsetIntParam(JNIEnv *jenv, jcla arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); if (!arg2) return 0; } - arg3 = (int)jarg3; - result = (SCIP_RETCODE)SCIPsetIntParam(arg1,(char const *)arg2,arg3); - jresult = (jint)result; + result = (scip::ObjEventhdlr *)SCIPfindObjEventhdlr(arg1,(char const *)arg2); + *(scip::ObjEventhdlr **)&jresult = result; if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPsetLongintParam(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3) { +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPcatchEvent(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3, jlong jarg4, jlong jarg5) { jint jresult = 0 ; SCIP *arg1 = (SCIP *) 0 ; - char *arg2 = (char *) 0 ; - long long arg3 ; + SCIP_EVENTTYPE arg2 ; + SCIP_EVENTHDLR *arg3 = (SCIP_EVENTHDLR *) 0 ; + SCIP_EVENTDATA *arg4 = (SCIP_EVENTDATA *) 0 ; + int *arg5 = (int *) 0 ; SCIP_RETCODE result; (void)jenv; (void)jcls; arg1 = *(SCIP **)&jarg1; - arg2 = 0; - if (jarg2) { - arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return 0; - } - arg3 = (long long)jarg3; - result = (SCIP_RETCODE)SCIPsetLongintParam(arg1,(char const *)arg2,arg3); + arg2 = (SCIP_EVENTTYPE)jarg2; + arg3 = *(SCIP_EVENTHDLR **)&jarg3; + arg4 = *(SCIP_EVENTDATA **)&jarg4; + arg5 = *(int **)&jarg5; + result = (SCIP_RETCODE)SCIPcatchEvent(arg1,arg2,arg3,arg4,arg5); jresult = (jint)result; - if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPsetRealParam(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jdouble jarg3) { +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1DIDNOTRUN_1get(JNIEnv *jenv, jclass jcls) { jint jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - char *arg2 = (char *) 0 ; - double arg3 ; - SCIP_RETCODE result; + SCIP_Result result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = 0; - if (jarg2) { - arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return 0; - } - arg3 = (double)jarg3; - result = (SCIP_RETCODE)SCIPsetRealParam(arg1,(char const *)arg2,arg3); + result = (SCIP_Result)SCIP_DIDNOTRUN; jresult = (jint)result; - if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPsetCharParam(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jchar jarg3) { +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1DELAYED_1get(JNIEnv *jenv, jclass jcls) { jint jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - char *arg2 = (char *) 0 ; - char arg3 ; - SCIP_RETCODE result; + SCIP_Result result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = 0; - if (jarg2) { - arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return 0; - } - arg3 = (char)jarg3; - result = (SCIP_RETCODE)SCIPsetCharParam(arg1,(char const *)arg2,arg3); + result = (SCIP_Result)SCIP_DELAYED; jresult = (jint)result; - if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPsetStringParam(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jstring jarg3) { +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1DIDNOTFIND_1get(JNIEnv *jenv, jclass jcls) { jint jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - char *arg2 = (char *) 0 ; - char *arg3 = (char *) 0 ; - SCIP_RETCODE result; + SCIP_Result result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = 0; - if (jarg2) { - arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return 0; - } - arg3 = 0; - if (jarg3) { - arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0); - if (!arg3) return 0; - } - result = (SCIP_RETCODE)SCIPsetStringParam(arg1,(char const *)arg2,(char const *)arg3); + result = (SCIP_Result)SCIP_DIDNOTFIND; jresult = (jint)result; - if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); - if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3); return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPsetPresolving(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2, jlong jarg3) { +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1FEASIBLE_1get(JNIEnv *jenv, jclass jcls) { jint jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - SCIP_PARAMSETTING arg2 ; - unsigned int arg3 ; - SCIP_RETCODE result; - + SCIP_Result result; + (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = (SCIP_PARAMSETTING)jarg2; - arg3 = (unsigned int)jarg3; - result = (SCIP_RETCODE)SCIPsetPresolving(arg1,arg2,arg3); - jresult = (jint)result; + result = (SCIP_Result)SCIP_FEASIBLE; + jresult = (jint)result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPsetHeuristics(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2, jlong jarg3) { +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1INFEASIBLE_1get(JNIEnv *jenv, jclass jcls) { jint jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - SCIP_PARAMSETTING arg2 ; - unsigned int arg3 ; - SCIP_RETCODE result; - + SCIP_Result result; + (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = (SCIP_PARAMSETTING)jarg2; - arg3 = (unsigned int)jarg3; - result = (SCIP_RETCODE)SCIPsetHeuristics(arg1,arg2,arg3); - jresult = (jint)result; + result = (SCIP_Result)SCIP_INFEASIBLE; + jresult = (jint)result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPsetEmphasis(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2, jlong jarg3) { +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1UNBOUNDED_1get(JNIEnv *jenv, jclass jcls) { jint jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - SCIP_PARAMEMPHASIS arg2 ; - unsigned int arg3 ; - SCIP_RETCODE result; + SCIP_Result result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = (SCIP_PARAMEMPHASIS)jarg2; - arg3 = (unsigned int)jarg3; - result = (SCIP_RETCODE)SCIPsetEmphasis(arg1,arg2,arg3); + result = (SCIP_Result)SCIP_UNBOUNDED; jresult = (jint)result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPsetObjsense(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) { +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1CUTOFF_1get(JNIEnv *jenv, jclass jcls) { jint jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - SCIP_OBJSENSE arg2 ; - SCIP_RETCODE result; + SCIP_Result result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = (SCIP_OBJSENSE)jarg2; - result = (SCIP_RETCODE)SCIPsetObjsense(arg1,arg2); + result = (SCIP_Result)SCIP_CUTOFF; jresult = (jint)result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPgetObjsense(JNIEnv *jenv, jclass jcls, jlong jarg1) { +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1SEPARATED_1get(JNIEnv *jenv, jclass jcls) { jint jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - SCIP_OBJSENSE result; + SCIP_Result result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - result = (SCIP_OBJSENSE)SCIPgetObjsense(arg1); + result = (SCIP_Result)SCIP_SEPARATED; jresult = (jint)result; return jresult; } -SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIPgetGap(JNIEnv *jenv, jclass jcls, jlong jarg1) { - jdouble jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - double result; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1NEWROUND_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Result result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - result = (double)SCIPgetGap(arg1); - jresult = (jdouble)result; + result = (SCIP_Result)SCIP_NEWROUND; + jresult = (jint)result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPchgVarObj(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jdouble jarg3) { +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1REDUCEDDOM_1get(JNIEnv *jenv, jclass jcls) { jint jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - SCIP_VAR *arg2 = (SCIP_VAR *) 0 ; - double arg3 ; - SCIP_RETCODE result; + SCIP_Result result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = *(SCIP_VAR **)&jarg2; - arg3 = (double)jarg3; - result = (SCIP_RETCODE)SCIPchgVarObj(arg1,arg2,arg3); + result = (SCIP_Result)SCIP_REDUCEDDOM; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1CONSADDED_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Result result; + + (void)jenv; + (void)jcls; + result = (SCIP_Result)SCIP_CONSADDED; jresult = (jint)result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPchgVarBranchPriority(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jint jarg3) { +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1CONSCHANGED_1get(JNIEnv *jenv, jclass jcls) { jint jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - SCIP_VAR *arg2 = (SCIP_VAR *) 0 ; - int arg3 ; - SCIP_RETCODE result; + SCIP_Result result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = *(SCIP_VAR **)&jarg2; - arg3 = (int)jarg3; - result = (SCIP_RETCODE)SCIPchgVarBranchPriority(arg1,arg2,arg3); + result = (SCIP_Result)SCIP_CONSCHANGED; jresult = (jint)result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPcreateSol(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1BRANCHED_1get(JNIEnv *jenv, jclass jcls) { jint jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - SCIP_SOL **arg2 = (SCIP_SOL **) 0 ; - SCIP_HEUR *arg3 = (SCIP_HEUR *) 0 ; - SCIP_RETCODE result; + SCIP_Result result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = *(SCIP_SOL ***)&jarg2; - arg3 = *(SCIP_HEUR **)&jarg3; - result = (SCIP_RETCODE)SCIPcreateSol(arg1,arg2,arg3); + result = (SCIP_Result)SCIP_BRANCHED; jresult = (jint)result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPcreatePartialSol(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1SOLVELP_1get(JNIEnv *jenv, jclass jcls) { jint jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - SCIP_SOL **arg2 = (SCIP_SOL **) 0 ; - SCIP_HEUR *arg3 = (SCIP_HEUR *) 0 ; - SCIP_RETCODE result; + SCIP_Result result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = *(SCIP_SOL ***)&jarg2; - arg3 = *(SCIP_HEUR **)&jarg3; - result = (SCIP_RETCODE)SCIPcreatePartialSol(arg1,arg2,arg3); + result = (SCIP_Result)SCIP_SOLVELP; jresult = (jint)result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPsetSolVal(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3, jdouble jarg4) { +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1FOUNDSOL_1get(JNIEnv *jenv, jclass jcls) { jint jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - SCIP_SOL *arg2 = (SCIP_SOL *) 0 ; - SCIP_VAR *arg3 = (SCIP_VAR *) 0 ; - double arg4 ; - SCIP_RETCODE result; + SCIP_Result result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = *(SCIP_SOL **)&jarg2; - arg3 = *(SCIP_VAR **)&jarg3; - arg4 = (double)jarg4; - result = (SCIP_RETCODE)SCIPsetSolVal(arg1,arg2,arg3,arg4); + result = (SCIP_Result)SCIP_FOUNDSOL; jresult = (jint)result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPsetSolVals(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jint jarg3, jlong jarg4, jlong jarg5) { +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1SUSPENDED_1get(JNIEnv *jenv, jclass jcls) { jint jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - SCIP_SOL *arg2 = (SCIP_SOL *) 0 ; - int arg3 ; - SCIP_VAR **arg4 = (SCIP_VAR **) 0 ; - double *arg5 = (double *) 0 ; - SCIP_RETCODE result; + SCIP_Result result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = *(SCIP_SOL **)&jarg2; - arg3 = (int)jarg3; - arg4 = *(SCIP_VAR ***)&jarg4; - arg5 = *(double **)&jarg5; - result = (SCIP_RETCODE)SCIPsetSolVals(arg1,arg2,arg3,arg4,arg5); + result = (SCIP_Result)SCIP_SUSPENDED; jresult = (jint)result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPaddSolFree(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1SUCCESS_1get(JNIEnv *jenv, jclass jcls) { jint jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - SCIP_SOL **arg2 = (SCIP_SOL **) 0 ; - unsigned int *arg3 = (unsigned int *) 0 ; - SCIP_RETCODE result; + SCIP_Result result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = *(SCIP_SOL ***)&jarg2; - arg3 = *(unsigned int **)&jarg3; - result = (SCIP_RETCODE)SCIPaddSolFree(arg1,arg2,arg3); + result = (SCIP_Result)SCIP_SUCCESS; jresult = (jint)result; return jresult; } -SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIPgetPrimalbound(JNIEnv *jenv, jclass jcls, jlong jarg1) { - jdouble jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - double result; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1DELAYNODE_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_Result result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - result = (double)SCIPgetPrimalbound(arg1); - jresult = (jdouble)result; + result = (SCIP_Result)SCIP_DELAYNODE; + jresult = (jint)result; return jresult; } -SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIPgetDualbound(JNIEnv *jenv, jclass jcls, jlong jarg1) { - jdouble jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - double result; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1LOCKTYPE_1MODEL_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_LockType result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - result = (double)SCIPgetDualbound(arg1); - jresult = (jdouble)result; + result = (SCIP_LockType)SCIP_LOCKTYPE_MODEL; + jresult = (jint)result; return jresult; } -SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIPgetSolvingTime(JNIEnv *jenv, jclass jcls, jlong jarg1) { - jdouble jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - double result; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIP_1LOCKTYPE_1CONFLICT_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SCIP_LockType result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - result = (double)SCIPgetSolvingTime(arg1); - jresult = (jdouble)result; + result = (SCIP_LockType)SCIP_LOCKTYPE_CONFLICT; + jresult = (jint)result; return jresult; } -SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_BMScheckEmptyMemory(JNIEnv *jenv, jclass jcls) { +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + (void)jenv; (void)jcls; - BMScheckEmptyMemory(); + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + if (arg1) (arg1)->scip_ = arg2; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_BMSgetMemoryUsed(JNIEnv *jenv, jclass jcls) { +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; - long long result; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *result = 0 ; (void)jenv; (void)jcls; - result = (long long)BMSgetMemoryUsed(); - jresult = (jlong)result; + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + result = (SCIP *) ((arg1)->scip_); + *(SCIP **)&jresult = result; return jresult; } -SWIGEXPORT jstring JNICALL Java_jscip_SCIPJNIJNI_SCIPvarGetName(JNIEnv *jenv, jclass jcls, jlong jarg1) { - jstring jresult = 0 ; - SCIP_VAR *arg1 = (SCIP_VAR *) 0 ; - char *result = 0 ; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1name_1_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + char *arg2 = (char *) 0 ; (void)jenv; (void)jcls; - arg1 = *(SCIP_VAR **)&jarg1; - result = (char *)SCIPvarGetName(arg1); - if (result) jresult = jenv->NewStringUTF((const char *)result); - return jresult; + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return ; + } + { + delete [] arg1->scip_name_; + if (arg2) { + arg1->scip_name_ = (char *) (new char[strlen((const char *)arg2)+1]); + strcpy((char *)arg1->scip_name_, (const char *)arg2); + } else { + arg1->scip_name_ = 0; + } + } + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPvarGetType(JNIEnv *jenv, jclass jcls, jlong jarg1) { - jint jresult = 0 ; - SCIP_VAR *arg1 = (SCIP_VAR *) 0 ; - SCIP_VARTYPE result; +SWIGEXPORT jstring JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1name_1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + char *result = 0 ; (void)jenv; (void)jcls; - arg1 = *(SCIP_VAR **)&jarg1; - result = (SCIP_VARTYPE)SCIPvarGetType(arg1); - jresult = (jint)result; + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + result = (char *) ((arg1)->scip_name_); + if (result) jresult = jenv->NewStringUTF((const char *)result); return jresult; } -SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIPvarGetLbLocal(JNIEnv *jenv, jclass jcls, jlong jarg1) { - jdouble jresult = 0 ; - SCIP_VAR *arg1 = (SCIP_VAR *) 0 ; - double result; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1desc_1_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + char *arg2 = (char *) 0 ; (void)jenv; (void)jcls; - arg1 = *(SCIP_VAR **)&jarg1; - result = (double)SCIPvarGetLbLocal(arg1); - jresult = (jdouble)result; - return jresult; + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return ; + } + { + delete [] arg1->scip_desc_; + if (arg2) { + arg1->scip_desc_ = (char *) (new char[strlen((const char *)arg2)+1]); + strcpy((char *)arg1->scip_desc_, (const char *)arg2); + } else { + arg1->scip_desc_ = 0; + } + } + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); } -SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIPvarGetUbLocal(JNIEnv *jenv, jclass jcls, jlong jarg1) { - jdouble jresult = 0 ; - SCIP_VAR *arg1 = (SCIP_VAR *) 0 ; - double result; +SWIGEXPORT jstring JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1desc_1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + char *result = 0 ; (void)jenv; (void)jcls; - arg1 = *(SCIP_VAR **)&jarg1; - result = (double)SCIPvarGetUbLocal(arg1); - jresult = (jdouble)result; + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + result = (char *) ((arg1)->scip_desc_); + if (result) jresult = jenv->NewStringUTF((const char *)result); return jresult; } -SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIPvarGetLbGlobal(JNIEnv *jenv, jclass jcls, jlong jarg1) { - jdouble jresult = 0 ; - SCIP_VAR *arg1 = (SCIP_VAR *) 0 ; - double result; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1sepapriority_1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + int result; (void)jenv; (void)jcls; - arg1 = *(SCIP_VAR **)&jarg1; - result = (double)SCIPvarGetLbGlobal(arg1); - jresult = (jdouble)result; + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + result = (int)(int) ((arg1)->scip_sepapriority_); + jresult = (jint)result; return jresult; } -SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIPvarGetUbGlobal(JNIEnv *jenv, jclass jcls, jlong jarg1) { - jdouble jresult = 0 ; - SCIP_VAR *arg1 = (SCIP_VAR *) 0 ; - double result; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1enfopriority_1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + int result; (void)jenv; (void)jcls; - arg1 = *(SCIP_VAR **)&jarg1; - result = (double)SCIPvarGetUbGlobal(arg1); - jresult = (jdouble)result; + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + result = (int)(int) ((arg1)->scip_enfopriority_); + jresult = (jint)result; return jresult; } -SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIPvarGetObj(JNIEnv *jenv, jclass jcls, jlong jarg1) { - jdouble jresult = 0 ; - SCIP_VAR *arg1 = (SCIP_VAR *) 0 ; - double result; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1checkpriority_1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + int result; (void)jenv; (void)jcls; - arg1 = *(SCIP_VAR **)&jarg1; - result = (double)SCIPvarGetObj(arg1); - jresult = (jdouble)result; + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + result = (int)(int) ((arg1)->scip_checkpriority_); + jresult = (jint)result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPvarGetBranchPriority(JNIEnv *jenv, jclass jcls, jlong jarg1) { +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1sepafreq_1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jint jresult = 0 ; - SCIP_VAR *arg1 = (SCIP_VAR *) 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; int result; (void)jenv; (void)jcls; - arg1 = *(SCIP_VAR **)&jarg1; - result = (int)SCIPvarGetBranchPriority(arg1); + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + result = (int)(int) ((arg1)->scip_sepafreq_); jresult = (jint)result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPsolGetDepth(JNIEnv *jenv, jclass jcls, jlong jarg1) { +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1propfreq_1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jint jresult = 0 ; - SCIP_SOL *arg1 = (SCIP_SOL *) 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; int result; (void)jenv; (void)jcls; - arg1 = *(SCIP_SOL **)&jarg1; - result = (int)SCIPsolGetDepth(arg1); + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + result = (int)(int) ((arg1)->scip_propfreq_); jresult = (jint)result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPsolGetIndex(JNIEnv *jenv, jclass jcls, jlong jarg1) { +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1eagerfreq_1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jint jresult = 0 ; - SCIP_SOL *arg1 = (SCIP_SOL *) 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; int result; (void)jenv; (void)jcls; - arg1 = *(SCIP_SOL **)&jarg1; - result = (int)SCIPsolGetIndex(arg1); + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + result = (int)(int) ((arg1)->scip_eagerfreq_); jresult = (jint)result; return jresult; } -SWIGEXPORT jstring JNICALL Java_jscip_SCIPJNIJNI_SCIPconsGetName(JNIEnv *jenv, jclass jcls, jlong jarg1) { - jstring jresult = 0 ; - SCIP_CONS *arg1 = (SCIP_CONS *) 0 ; - char *result = 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1maxprerounds_1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + int result; (void)jenv; (void)jcls; - arg1 = *(SCIP_CONS **)&jarg1; - result = (char *)SCIPconsGetName(arg1); - if (result) jresult = jenv->NewStringUTF((const char *)result); + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + result = (int)(int) ((arg1)->scip_maxprerounds_); + jresult = (jint)result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPgetDualSolVal(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3, jlong jarg4) { - jint jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - SCIP_CONS *arg2 = (SCIP_CONS *) 0 ; - double *arg3 = (double *) 0 ; - unsigned int *arg4 = (unsigned int *) 0 ; - SCIP_RETCODE result; - +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1delaysepa_1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + unsigned int result; + (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = *(SCIP_CONS **)&jarg2; - arg3 = *(double **)&jarg3; - arg4 = *(unsigned int **)&jarg4; - result = (SCIP_RETCODE)SCIPgetDualSolVal(arg1,arg2,arg3,arg4); - jresult = (jint)result; + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + result = (unsigned int)(unsigned int) ((arg1)->scip_delaysepa_); + jresult = (jlong)result; return jresult; } -SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIPgetDualsolLinear(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { - jdouble jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - SCIP_CONS *arg2 = (SCIP_CONS *) 0 ; - double result; - +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1delayprop_1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + unsigned int result; + (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = *(SCIP_CONS **)&jarg2; - result = (double)SCIPgetDualsolLinear(arg1,arg2); - jresult = (jdouble)result; + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + result = (unsigned int)(unsigned int) ((arg1)->scip_delayprop_); + jresult = (jlong)result; return jresult; } -SWIGEXPORT jdouble JNICALL Java_jscip_SCIPJNIJNI_SCIPgetDualfarkasLinear(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { - jdouble jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - SCIP_CONS *arg2 = (SCIP_CONS *) 0 ; - double result; +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1needscons_1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + unsigned int result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + result = (unsigned int)(unsigned int) ((arg1)->scip_needscons_); + jresult = (jlong)result; + return jresult; +} + +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1proptiming_1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + unsigned int result; + (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = *(SCIP_CONS **)&jarg2; - result = (double)SCIPgetDualfarkasLinear(arg1,arg2); - jresult = (jdouble)result; + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + result = (unsigned int)(unsigned int) ((arg1)->scip_proptiming_); + jresult = (jlong)result; return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_ObjMessagehdlr_1scip_1bufferedoutput_1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1presoltiming_1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; - scip::ObjMessagehdlr *arg1 = (scip::ObjMessagehdlr *) 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; unsigned int result; (void)jenv; (void)jcls; (void)jarg1_; - arg1 = *(scip::ObjMessagehdlr **)&jarg1; - result = (unsigned int)(unsigned int) ((arg1)->scip_bufferedoutput_); + arg1 = *(scip::ObjConshdlr **)&jarg1; + result = (unsigned int)(unsigned int) ((arg1)->scip_presoltiming_); jresult = (jlong)result; return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_new_1ObjMessagehdlr(JNIEnv *jenv, jclass jcls, jlong jarg1) { +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_new_1ObjConshdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jstring jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jint jarg9, jint jarg10, jlong jarg11, jlong jarg12, jlong jarg13, jlong jarg14, jlong jarg15) { jlong jresult = 0 ; - unsigned int arg1 ; - scip::ObjMessagehdlr *result = 0 ; + SCIP *arg1 = (SCIP *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + int arg4 ; + int arg5 ; + int arg6 ; + int arg7 ; + int arg8 ; + int arg9 ; + int arg10 ; + unsigned int arg11 ; + unsigned int arg12 ; + unsigned int arg13 ; + unsigned int arg14 ; + unsigned int arg15 ; + scip::ObjConshdlr *result = 0 ; (void)jenv; (void)jcls; - arg1 = (unsigned int)jarg1; - result = (scip::ObjMessagehdlr *)new SwigDirector_ObjMessagehdlr(jenv,arg1); - *(scip::ObjMessagehdlr **)&jresult = result; + arg1 = *(SCIP **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = 0; + if (jarg3) { + arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0); + if (!arg3) return 0; + } + arg4 = (int)jarg4; + arg5 = (int)jarg5; + arg6 = (int)jarg6; + arg7 = (int)jarg7; + arg8 = (int)jarg8; + arg9 = (int)jarg9; + arg10 = (int)jarg10; + arg11 = (unsigned int)jarg11; + arg12 = (unsigned int)jarg12; + arg13 = (unsigned int)jarg13; + arg14 = (unsigned int)jarg14; + arg15 = (unsigned int)jarg15; + result = (scip::ObjConshdlr *)new SwigDirector_ObjConshdlr(jenv,arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15); + *(scip::ObjConshdlr **)&jresult = result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3); return jresult; } -SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_delete_1ObjMessagehdlr(JNIEnv *jenv, jclass jcls, jlong jarg1) { - scip::ObjMessagehdlr *arg1 = (scip::ObjMessagehdlr *) 0 ; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_delete_1ObjConshdlr(JNIEnv *jenv, jclass jcls, jlong jarg1) { + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; (void)jenv; (void)jcls; - arg1 = *(scip::ObjMessagehdlr **)&jarg1; + arg1 = *(scip::ObjConshdlr **)&jarg1; delete arg1; } -SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_ObjMessagehdlr_1scip_1error(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jstring jarg4) { - scip::ObjMessagehdlr *arg1 = (scip::ObjMessagehdlr *) 0 ; - SCIP_MESSAGEHDLR *arg2 = (SCIP_MESSAGEHDLR *) 0 ; - FILE *arg3 = (FILE *) 0 ; - char *arg4 = (char *) 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1free(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; (void)jarg1_; - arg1 = *(scip::ObjMessagehdlr **)&jarg1; - arg2 = *(SCIP_MESSAGEHDLR **)&jarg2; - arg3 = *(FILE **)&jarg3; - arg4 = 0; - if (jarg4) { - arg4 = (char *)jenv->GetStringUTFChars(jarg4, 0); - if (!arg4) return ; - } - (arg1)->scip_error(arg2,arg3,(char const *)arg4); - if (arg4) jenv->ReleaseStringUTFChars(jarg4, (const char *)arg4); + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + result = (SCIP_RETCODE)(arg1)->scip_free(arg2,arg3); + jresult = (jint)result; + return jresult; } -SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_ObjMessagehdlr_1scip_1errorSwigExplicitObjMessagehdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jstring jarg4) { - scip::ObjMessagehdlr *arg1 = (scip::ObjMessagehdlr *) 0 ; - SCIP_MESSAGEHDLR *arg2 = (SCIP_MESSAGEHDLR *) 0 ; - FILE *arg3 = (FILE *) 0 ; - char *arg4 = (char *) 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1freeSwigExplicitObjConshdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; (void)jarg1_; - arg1 = *(scip::ObjMessagehdlr **)&jarg1; - arg2 = *(SCIP_MESSAGEHDLR **)&jarg2; - arg3 = *(FILE **)&jarg3; - arg4 = 0; - if (jarg4) { - arg4 = (char *)jenv->GetStringUTFChars(jarg4, 0); - if (!arg4) return ; - } - (arg1)->scip::ObjMessagehdlr::scip_error(arg2,arg3,(char const *)arg4); - if (arg4) jenv->ReleaseStringUTFChars(jarg4, (const char *)arg4); + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + result = (SCIP_RETCODE)(arg1)->scip::ObjConshdlr::scip_free(arg2,arg3); + jresult = (jint)result; + return jresult; } -SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_ObjMessagehdlr_1scip_1warning(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jstring jarg4) { - scip::ObjMessagehdlr *arg1 = (scip::ObjMessagehdlr *) 0 ; - SCIP_MESSAGEHDLR *arg2 = (SCIP_MESSAGEHDLR *) 0 ; - FILE *arg3 = (FILE *) 0 ; - char *arg4 = (char *) 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1init(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jint jarg5) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS **arg4 = (SCIP_CONS **) 0 ; + int arg5 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; (void)jarg1_; - arg1 = *(scip::ObjMessagehdlr **)&jarg1; - arg2 = *(SCIP_MESSAGEHDLR **)&jarg2; - arg3 = *(FILE **)&jarg3; - arg4 = 0; - if (jarg4) { - arg4 = (char *)jenv->GetStringUTFChars(jarg4, 0); - if (!arg4) return ; - } - (arg1)->scip_warning(arg2,arg3,(char const *)arg4); - if (arg4) jenv->ReleaseStringUTFChars(jarg4, (const char *)arg4); + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS ***)&jarg4; + arg5 = (int)jarg5; + result = (SCIP_RETCODE)(arg1)->scip_init(arg2,arg3,arg4,arg5); + jresult = (jint)result; + return jresult; } -SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_ObjMessagehdlr_1scip_1warningSwigExplicitObjMessagehdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jstring jarg4) { - scip::ObjMessagehdlr *arg1 = (scip::ObjMessagehdlr *) 0 ; - SCIP_MESSAGEHDLR *arg2 = (SCIP_MESSAGEHDLR *) 0 ; - FILE *arg3 = (FILE *) 0 ; - char *arg4 = (char *) 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1initSwigExplicitObjConshdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jint jarg5) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS **arg4 = (SCIP_CONS **) 0 ; + int arg5 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; (void)jarg1_; - arg1 = *(scip::ObjMessagehdlr **)&jarg1; - arg2 = *(SCIP_MESSAGEHDLR **)&jarg2; - arg3 = *(FILE **)&jarg3; - arg4 = 0; - if (jarg4) { - arg4 = (char *)jenv->GetStringUTFChars(jarg4, 0); - if (!arg4) return ; - } - (arg1)->scip::ObjMessagehdlr::scip_warning(arg2,arg3,(char const *)arg4); - if (arg4) jenv->ReleaseStringUTFChars(jarg4, (const char *)arg4); + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS ***)&jarg4; + arg5 = (int)jarg5; + result = (SCIP_RETCODE)(arg1)->scip::ObjConshdlr::scip_init(arg2,arg3,arg4,arg5); + jresult = (jint)result; + return jresult; } -SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_ObjMessagehdlr_1scip_1dialog(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jstring jarg4) { - scip::ObjMessagehdlr *arg1 = (scip::ObjMessagehdlr *) 0 ; - SCIP_MESSAGEHDLR *arg2 = (SCIP_MESSAGEHDLR *) 0 ; - FILE *arg3 = (FILE *) 0 ; - char *arg4 = (char *) 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1exit(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jint jarg5) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS **arg4 = (SCIP_CONS **) 0 ; + int arg5 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; (void)jarg1_; - arg1 = *(scip::ObjMessagehdlr **)&jarg1; - arg2 = *(SCIP_MESSAGEHDLR **)&jarg2; - arg3 = *(FILE **)&jarg3; - arg4 = 0; - if (jarg4) { - arg4 = (char *)jenv->GetStringUTFChars(jarg4, 0); - if (!arg4) return ; - } - (arg1)->scip_dialog(arg2,arg3,(char const *)arg4); - if (arg4) jenv->ReleaseStringUTFChars(jarg4, (const char *)arg4); + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS ***)&jarg4; + arg5 = (int)jarg5; + result = (SCIP_RETCODE)(arg1)->scip_exit(arg2,arg3,arg4,arg5); + jresult = (jint)result; + return jresult; } -SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_ObjMessagehdlr_1scip_1dialogSwigExplicitObjMessagehdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jstring jarg4) { - scip::ObjMessagehdlr *arg1 = (scip::ObjMessagehdlr *) 0 ; - SCIP_MESSAGEHDLR *arg2 = (SCIP_MESSAGEHDLR *) 0 ; - FILE *arg3 = (FILE *) 0 ; - char *arg4 = (char *) 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1exitSwigExplicitObjConshdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jint jarg5) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS **arg4 = (SCIP_CONS **) 0 ; + int arg5 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; (void)jarg1_; - arg1 = *(scip::ObjMessagehdlr **)&jarg1; - arg2 = *(SCIP_MESSAGEHDLR **)&jarg2; - arg3 = *(FILE **)&jarg3; - arg4 = 0; - if (jarg4) { - arg4 = (char *)jenv->GetStringUTFChars(jarg4, 0); - if (!arg4) return ; - } - (arg1)->scip::ObjMessagehdlr::scip_dialog(arg2,arg3,(char const *)arg4); - if (arg4) jenv->ReleaseStringUTFChars(jarg4, (const char *)arg4); + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS ***)&jarg4; + arg5 = (int)jarg5; + result = (SCIP_RETCODE)(arg1)->scip::ObjConshdlr::scip_exit(arg2,arg3,arg4,arg5); + jresult = (jint)result; + return jresult; } -SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_ObjMessagehdlr_1scip_1info(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jstring jarg4) { - scip::ObjMessagehdlr *arg1 = (scip::ObjMessagehdlr *) 0 ; - SCIP_MESSAGEHDLR *arg2 = (SCIP_MESSAGEHDLR *) 0 ; - FILE *arg3 = (FILE *) 0 ; - char *arg4 = (char *) 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1initpre(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jint jarg5) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS **arg4 = (SCIP_CONS **) 0 ; + int arg5 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; (void)jarg1_; - arg1 = *(scip::ObjMessagehdlr **)&jarg1; - arg2 = *(SCIP_MESSAGEHDLR **)&jarg2; - arg3 = *(FILE **)&jarg3; - arg4 = 0; - if (jarg4) { - arg4 = (char *)jenv->GetStringUTFChars(jarg4, 0); - if (!arg4) return ; - } - (arg1)->scip_info(arg2,arg3,(char const *)arg4); - if (arg4) jenv->ReleaseStringUTFChars(jarg4, (const char *)arg4); + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS ***)&jarg4; + arg5 = (int)jarg5; + result = (SCIP_RETCODE)(arg1)->scip_initpre(arg2,arg3,arg4,arg5); + jresult = (jint)result; + return jresult; } -SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_ObjMessagehdlr_1scip_1infoSwigExplicitObjMessagehdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jstring jarg4) { - scip::ObjMessagehdlr *arg1 = (scip::ObjMessagehdlr *) 0 ; - SCIP_MESSAGEHDLR *arg2 = (SCIP_MESSAGEHDLR *) 0 ; - FILE *arg3 = (FILE *) 0 ; - char *arg4 = (char *) 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1initpreSwigExplicitObjConshdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jint jarg5) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS **arg4 = (SCIP_CONS **) 0 ; + int arg5 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; (void)jarg1_; - arg1 = *(scip::ObjMessagehdlr **)&jarg1; - arg2 = *(SCIP_MESSAGEHDLR **)&jarg2; - arg3 = *(FILE **)&jarg3; - arg4 = 0; - if (jarg4) { - arg4 = (char *)jenv->GetStringUTFChars(jarg4, 0); - if (!arg4) return ; - } - (arg1)->scip::ObjMessagehdlr::scip_info(arg2,arg3,(char const *)arg4); - if (arg4) jenv->ReleaseStringUTFChars(jarg4, (const char *)arg4); + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS ***)&jarg4; + arg5 = (int)jarg5; + result = (SCIP_RETCODE)(arg1)->scip::ObjConshdlr::scip_initpre(arg2,arg3,arg4,arg5); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1exitpre(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jint jarg5) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS **arg4 = (SCIP_CONS **) 0 ; + int arg5 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS ***)&jarg4; + arg5 = (int)jarg5; + result = (SCIP_RETCODE)(arg1)->scip_exitpre(arg2,arg3,arg4,arg5); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1exitpreSwigExplicitObjConshdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jint jarg5) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS **arg4 = (SCIP_CONS **) 0 ; + int arg5 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS ***)&jarg4; + arg5 = (int)jarg5; + result = (SCIP_RETCODE)(arg1)->scip::ObjConshdlr::scip_exitpre(arg2,arg3,arg4,arg5); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1initsol(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jint jarg5) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS **arg4 = (SCIP_CONS **) 0 ; + int arg5 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS ***)&jarg4; + arg5 = (int)jarg5; + result = (SCIP_RETCODE)(arg1)->scip_initsol(arg2,arg3,arg4,arg5); + jresult = (jint)result; + return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjMessagehdlr_1scip_1free(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1initsolSwigExplicitObjConshdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jint jarg5) { jint jresult = 0 ; - scip::ObjMessagehdlr *arg1 = (scip::ObjMessagehdlr *) 0 ; - SCIP_MESSAGEHDLR *arg2 = (SCIP_MESSAGEHDLR *) 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS **arg4 = (SCIP_CONS **) 0 ; + int arg5 ; SCIP_RETCODE result; (void)jenv; (void)jcls; (void)jarg1_; - arg1 = *(scip::ObjMessagehdlr **)&jarg1; - arg2 = *(SCIP_MESSAGEHDLR **)&jarg2; - result = (SCIP_RETCODE)(arg1)->scip_free(arg2); + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS ***)&jarg4; + arg5 = (int)jarg5; + result = (SCIP_RETCODE)(arg1)->scip::ObjConshdlr::scip_initsol(arg2,arg3,arg4,arg5); jresult = (jint)result; return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjMessagehdlr_1scip_1freeSwigExplicitObjMessagehdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1exitsol(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jint jarg5, jlong jarg6) { jint jresult = 0 ; - scip::ObjMessagehdlr *arg1 = (scip::ObjMessagehdlr *) 0 ; - SCIP_MESSAGEHDLR *arg2 = (SCIP_MESSAGEHDLR *) 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS **arg4 = (SCIP_CONS **) 0 ; + int arg5 ; + unsigned int arg6 ; SCIP_RETCODE result; (void)jenv; (void)jcls; (void)jarg1_; - arg1 = *(scip::ObjMessagehdlr **)&jarg1; - arg2 = *(SCIP_MESSAGEHDLR **)&jarg2; - result = (SCIP_RETCODE)(arg1)->scip::ObjMessagehdlr::scip_free(arg2); + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS ***)&jarg4; + arg5 = (int)jarg5; + arg6 = (unsigned int)jarg6; + result = (SCIP_RETCODE)(arg1)->scip_exitsol(arg2,arg3,arg4,arg5,arg6); jresult = (jint)result; return jresult; } -SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_ObjMessagehdlr_1director_1connect(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jswig_mem_own, jboolean jweak_global) { - scip::ObjMessagehdlr *obj = *((scip::ObjMessagehdlr **)&objarg); +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1exitsolSwigExplicitObjConshdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jint jarg5, jlong jarg6) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS **arg4 = (SCIP_CONS **) 0 ; + int arg5 ; + unsigned int arg6 ; + SCIP_RETCODE result; + + (void)jenv; (void)jcls; - SwigDirector_ObjMessagehdlr *director = static_cast(obj); - director->swig_connect_director(jenv, jself, jenv->GetObjectClass(jself), (jswig_mem_own == JNI_TRUE), (jweak_global == JNI_TRUE)); + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS ***)&jarg4; + arg5 = (int)jarg5; + arg6 = (unsigned int)jarg6; + result = (SCIP_RETCODE)(arg1)->scip::ObjConshdlr::scip_exitsol(arg2,arg3,arg4,arg5,arg6); + jresult = (jint)result; + return jresult; } -SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_ObjMessagehdlr_1change_1ownership(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jtake_or_release) { - scip::ObjMessagehdlr *obj = *((scip::ObjMessagehdlr **)&objarg); - SwigDirector_ObjMessagehdlr *director = dynamic_cast(obj); +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1delete(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jlong jarg5) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS *arg4 = (SCIP_CONS *) 0 ; + SCIP_CONSDATA **arg5 = (SCIP_CONSDATA **) 0 ; + SCIP_RETCODE result; + + (void)jenv; (void)jcls; - if (director) { - director->swig_java_change_ownership(jenv, jself, jtake_or_release ? true : false); - } + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS **)&jarg4; + arg5 = *(SCIP_CONSDATA ***)&jarg5; + result = (SCIP_RETCODE)(arg1)->scip_delete(arg2,arg3,arg4,arg5); + jresult = (jint)result; + return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIPgetObjMessagehdlr(JNIEnv *jenv, jclass jcls, jlong jarg1) { - jlong jresult = 0 ; - SCIP_MESSAGEHDLR *arg1 = (SCIP_MESSAGEHDLR *) 0 ; - scip::ObjMessagehdlr *result = 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1deleteSwigExplicitObjConshdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jlong jarg5) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS *arg4 = (SCIP_CONS *) 0 ; + SCIP_CONSDATA **arg5 = (SCIP_CONSDATA **) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP_MESSAGEHDLR **)&jarg1; - result = (scip::ObjMessagehdlr *)SCIPgetObjMessagehdlr(arg1); - *(scip::ObjMessagehdlr **)&jresult = result; + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS **)&jarg4; + arg5 = *(SCIP_CONSDATA ***)&jarg5; + result = (SCIP_RETCODE)(arg1)->scip::ObjConshdlr::scip_delete(arg2,arg3,arg4,arg5); + jresult = (jint)result; return jresult; } -SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIPsetStaticErrorPrintingMessagehdlr(JNIEnv *jenv, jclass jcls, jlong jarg1) { - SCIP_MESSAGEHDLR *arg1 = (SCIP_MESSAGEHDLR *) 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1trans(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jlong jarg5) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS *arg4 = (SCIP_CONS *) 0 ; + SCIP_CONS **arg5 = (SCIP_CONS **) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP_MESSAGEHDLR **)&jarg1; - SCIPsetStaticErrorPrintingMessagehdlr(arg1); + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS **)&jarg4; + arg5 = *(SCIP_CONS ***)&jarg5; + result = (SCIP_RETCODE)(arg1)->scip_trans(arg2,arg3,arg4,arg5); + jresult = (jint)result; + return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPsetMessagehdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1transSwigExplicitObjConshdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jlong jarg5) { jint jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - SCIP_MESSAGEHDLR *arg2 = (SCIP_MESSAGEHDLR *) 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS *arg4 = (SCIP_CONS *) 0 ; + SCIP_CONS **arg5 = (SCIP_CONS **) 0 ; SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = *(SCIP_MESSAGEHDLR **)&jarg2; - result = (SCIP_RETCODE)SCIPsetMessagehdlr(arg1,arg2); + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS **)&jarg4; + arg5 = *(SCIP_CONS ***)&jarg5; + result = (SCIP_RETCODE)(arg1)->scip::ObjConshdlr::scip_trans(arg2,arg3,arg4,arg5); jresult = (jint)result; return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIPgetMessagehdlr(JNIEnv *jenv, jclass jcls, jlong jarg1) { - jlong jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - SCIP_MESSAGEHDLR *result = 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1initlp(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jint jarg5, jlong jarg6) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS **arg4 = (SCIP_CONS **) 0 ; + int arg5 ; + unsigned int *arg6 = (unsigned int *) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - result = (SCIP_MESSAGEHDLR *)SCIPgetMessagehdlr(arg1); - *(SCIP_MESSAGEHDLR **)&jresult = result; + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS ***)&jarg4; + arg5 = (int)jarg5; + arg6 = *(unsigned int **)&jarg6; + result = (SCIP_RETCODE)(arg1)->scip_initlp(arg2,arg3,arg4,arg5,arg6); + jresult = (jint)result; return jresult; } -SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_SCIPsetMessagehdlrLogfile(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2) { - SCIP *arg1 = (SCIP *) 0 ; - char *arg2 = (char *) 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1initlpSwigExplicitObjConshdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jint jarg5, jlong jarg6) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS **arg4 = (SCIP_CONS **) 0 ; + int arg5 ; + unsigned int *arg6 = (unsigned int *) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = 0; - if (jarg2) { - arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return ; - } - SCIPsetMessagehdlrLogfile(arg1,(char const *)arg2); - if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS ***)&jarg4; + arg5 = (int)jarg5; + arg6 = *(unsigned int **)&jarg6; + result = (SCIP_RETCODE)(arg1)->scip::ObjConshdlr::scip_initlp(arg2,arg3,arg4,arg5,arg6); + jresult = (jint)result; + return jresult; } -SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPgetVerbLevel(JNIEnv *jenv, jclass jcls, jlong jarg1) { +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1sepalp(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jint jarg5, jint jarg6, jlong jarg7) { jint jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - SCIP_VERBLEVEL result; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS **arg4 = (SCIP_CONS **) 0 ; + int arg5 ; + int arg6 ; + SCIP_Result *arg7 = (SCIP_Result *) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - result = (SCIP_VERBLEVEL)SCIPgetVerbLevel(arg1); + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS ***)&jarg4; + arg5 = (int)jarg5; + arg6 = (int)jarg6; + arg7 = *(SCIP_Result **)&jarg7; + result = (SCIP_RETCODE)(arg1)->scip_sepalp(arg2,arg3,arg4,arg5,arg6,arg7); jresult = (jint)result; return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createSCIP(JNIEnv *jenv, jclass jcls) { - jlong jresult = 0 ; - SCIP *result = 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1sepalpSwigExplicitObjConshdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jint jarg5, jint jarg6, jlong jarg7) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS **arg4 = (SCIP_CONS **) 0 ; + int arg5 ; + int arg6 ; + SCIP_Result *arg7 = (SCIP_Result *) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - result = (SCIP *)createSCIP(); - *(SCIP **)&jresult = result; + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS ***)&jarg4; + arg5 = (int)jarg5; + arg6 = (int)jarg6; + arg7 = *(SCIP_Result **)&jarg7; + result = (SCIP_RETCODE)(arg1)->scip::ObjConshdlr::scip_sepalp(arg2,arg3,arg4,arg5,arg6,arg7); + jresult = (jint)result; return jresult; } -SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_freeSCIP(JNIEnv *jenv, jclass jcls, jlong jarg1) { - SCIP *arg1 = (SCIP *) 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1sepasol(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jint jarg5, jint jarg6, jlong jarg7, jlong jarg8) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS **arg4 = (SCIP_CONS **) 0 ; + int arg5 ; + int arg6 ; + SCIP_SOL *arg7 = (SCIP_SOL *) 0 ; + SCIP_Result *arg8 = (SCIP_Result *) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - freeSCIP(arg1); + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS ***)&jarg4; + arg5 = (int)jarg5; + arg6 = (int)jarg6; + arg7 = *(SCIP_SOL **)&jarg7; + arg8 = *(SCIP_Result **)&jarg8; + result = (SCIP_RETCODE)(arg1)->scip_sepasol(arg2,arg3,arg4,arg5,arg6,arg7,arg8); + jresult = (jint)result; + return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createVar(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jdouble jarg3, jdouble jarg4, jdouble jarg5, jint jarg6) { - jlong jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - char *arg2 = (char *) 0 ; - double arg3 ; - double arg4 ; - double arg5 ; - SCIP_VARTYPE arg6 ; - SCIP_VAR *result = 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1sepasolSwigExplicitObjConshdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jint jarg5, jint jarg6, jlong jarg7, jlong jarg8) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS **arg4 = (SCIP_CONS **) 0 ; + int arg5 ; + int arg6 ; + SCIP_SOL *arg7 = (SCIP_SOL *) 0 ; + SCIP_Result *arg8 = (SCIP_Result *) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = 0; - if (jarg2) { - arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return 0; - } - arg3 = (double)jarg3; - arg4 = (double)jarg4; - arg5 = (double)jarg5; - arg6 = (SCIP_VARTYPE)jarg6; - result = (SCIP_VAR *)createVar(arg1,(char const *)arg2,arg3,arg4,arg5,arg6); - *(SCIP_VAR **)&jresult = result; - if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS ***)&jarg4; + arg5 = (int)jarg5; + arg6 = (int)jarg6; + arg7 = *(SCIP_SOL **)&jarg7; + arg8 = *(SCIP_Result **)&jarg8; + result = (SCIP_RETCODE)(arg1)->scip::ObjConshdlr::scip_sepasol(arg2,arg3,arg4,arg5,arg6,arg7,arg8); + jresult = (jint)result; return jresult; } -SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_releaseVar(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { - SCIP *arg1 = (SCIP *) 0 ; - SCIP_VAR *arg2 = (SCIP_VAR *) 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1enfolp(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jint jarg5, jint jarg6, jlong jarg7, jlong jarg8) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS **arg4 = (SCIP_CONS **) 0 ; + int arg5 ; + int arg6 ; + unsigned int arg7 ; + SCIP_Result *arg8 = (SCIP_Result *) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = *(SCIP_VAR **)&jarg2; - releaseVar(arg1,arg2); + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS ***)&jarg4; + arg5 = (int)jarg5; + arg6 = (int)jarg6; + arg7 = (unsigned int)jarg7; + arg8 = *(SCIP_Result **)&jarg8; + result = (SCIP_RETCODE)(arg1)->scip_enfolp(arg2,arg3,arg4,arg5,arg6,arg7,arg8); + jresult = (jint)result; + return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createExprAbs(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { - jlong jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - SCIP_EXPR *arg2 = (SCIP_EXPR *) 0 ; - SCIP_EXPR *result = 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1enfolpSwigExplicitObjConshdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jint jarg5, jint jarg6, jlong jarg7, jlong jarg8) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS **arg4 = (SCIP_CONS **) 0 ; + int arg5 ; + int arg6 ; + unsigned int arg7 ; + SCIP_Result *arg8 = (SCIP_Result *) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = *(SCIP_EXPR **)&jarg2; - result = (SCIP_EXPR *)createExprAbs(arg1,arg2); - *(SCIP_EXPR **)&jresult = result; + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS ***)&jarg4; + arg5 = (int)jarg5; + arg6 = (int)jarg6; + arg7 = (unsigned int)jarg7; + arg8 = *(SCIP_Result **)&jarg8; + result = (SCIP_RETCODE)(arg1)->scip::ObjConshdlr::scip_enfolp(arg2,arg3,arg4,arg5,arg6,arg7,arg8); + jresult = (jint)result; return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createExprEntropy(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { - jlong jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - SCIP_EXPR *arg2 = (SCIP_EXPR *) 0 ; - SCIP_EXPR *result = 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1enforelax(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jlong jarg5, jint jarg6, jint jarg7, jlong jarg8, jlong jarg9) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_SOL *arg3 = (SCIP_SOL *) 0 ; + SCIP_CONSHDLR *arg4 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS **arg5 = (SCIP_CONS **) 0 ; + int arg6 ; + int arg7 ; + unsigned int arg8 ; + SCIP_Result *arg9 = (SCIP_Result *) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = *(SCIP_EXPR **)&jarg2; - result = (SCIP_EXPR *)createExprEntropy(arg1,arg2); - *(SCIP_EXPR **)&jresult = result; + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_SOL **)&jarg3; + arg4 = *(SCIP_CONSHDLR **)&jarg4; + arg5 = *(SCIP_CONS ***)&jarg5; + arg6 = (int)jarg6; + arg7 = (int)jarg7; + arg8 = (unsigned int)jarg8; + arg9 = *(SCIP_Result **)&jarg9; + result = (SCIP_RETCODE)(arg1)->scip_enforelax(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + jresult = (jint)result; return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createExprExp(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { - jlong jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - SCIP_EXPR *arg2 = (SCIP_EXPR *) 0 ; - SCIP_EXPR *result = 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1enforelaxSwigExplicitObjConshdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jlong jarg5, jint jarg6, jint jarg7, jlong jarg8, jlong jarg9) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_SOL *arg3 = (SCIP_SOL *) 0 ; + SCIP_CONSHDLR *arg4 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS **arg5 = (SCIP_CONS **) 0 ; + int arg6 ; + int arg7 ; + unsigned int arg8 ; + SCIP_Result *arg9 = (SCIP_Result *) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = *(SCIP_EXPR **)&jarg2; - result = (SCIP_EXPR *)createExprExp(arg1,arg2); - *(SCIP_EXPR **)&jresult = result; + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_SOL **)&jarg3; + arg4 = *(SCIP_CONSHDLR **)&jarg4; + arg5 = *(SCIP_CONS ***)&jarg5; + arg6 = (int)jarg6; + arg7 = (int)jarg7; + arg8 = (unsigned int)jarg8; + arg9 = *(SCIP_Result **)&jarg9; + result = (SCIP_RETCODE)(arg1)->scip::ObjConshdlr::scip_enforelax(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + jresult = (jint)result; return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createExprLog(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { - jlong jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - SCIP_EXPR *arg2 = (SCIP_EXPR *) 0 ; - SCIP_EXPR *result = 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1enfops(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jint jarg5, jint jarg6, jlong jarg7, jlong jarg8, jlong jarg9) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS **arg4 = (SCIP_CONS **) 0 ; + int arg5 ; + int arg6 ; + unsigned int arg7 ; + unsigned int arg8 ; + SCIP_Result *arg9 = (SCIP_Result *) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = *(SCIP_EXPR **)&jarg2; - result = (SCIP_EXPR *)createExprLog(arg1,arg2); - *(SCIP_EXPR **)&jresult = result; + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS ***)&jarg4; + arg5 = (int)jarg5; + arg6 = (int)jarg6; + arg7 = (unsigned int)jarg7; + arg8 = (unsigned int)jarg8; + arg9 = *(SCIP_Result **)&jarg9; + result = (SCIP_RETCODE)(arg1)->scip_enfops(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + jresult = (jint)result; return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createExprPow(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jdouble jarg3) { - jlong jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - SCIP_EXPR *arg2 = (SCIP_EXPR *) 0 ; - double arg3 ; - SCIP_EXPR *result = 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1enfopsSwigExplicitObjConshdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jint jarg5, jint jarg6, jlong jarg7, jlong jarg8, jlong jarg9) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS **arg4 = (SCIP_CONS **) 0 ; + int arg5 ; + int arg6 ; + unsigned int arg7 ; + unsigned int arg8 ; + SCIP_Result *arg9 = (SCIP_Result *) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = *(SCIP_EXPR **)&jarg2; - arg3 = (double)jarg3; - result = (SCIP_EXPR *)createExprPow(arg1,arg2,arg3); - *(SCIP_EXPR **)&jresult = result; + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS ***)&jarg4; + arg5 = (int)jarg5; + arg6 = (int)jarg6; + arg7 = (unsigned int)jarg7; + arg8 = (unsigned int)jarg8; + arg9 = *(SCIP_Result **)&jarg9; + result = (SCIP_RETCODE)(arg1)->scip::ObjConshdlr::scip_enfops(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + jresult = (jint)result; return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createExprSignpower(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jdouble jarg3) { - jlong jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - SCIP_EXPR *arg2 = (SCIP_EXPR *) 0 ; - double arg3 ; - SCIP_EXPR *result = 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1check(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jint jarg5, jlong jarg6, jlong jarg7, jlong jarg8, jlong jarg9, jlong jarg10, jlong jarg11) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS **arg4 = (SCIP_CONS **) 0 ; + int arg5 ; + SCIP_SOL *arg6 = (SCIP_SOL *) 0 ; + unsigned int arg7 ; + unsigned int arg8 ; + unsigned int arg9 ; + unsigned int arg10 ; + SCIP_Result *arg11 = (SCIP_Result *) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = *(SCIP_EXPR **)&jarg2; - arg3 = (double)jarg3; - result = (SCIP_EXPR *)createExprSignpower(arg1,arg2,arg3); - *(SCIP_EXPR **)&jresult = result; + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS ***)&jarg4; + arg5 = (int)jarg5; + arg6 = *(SCIP_SOL **)&jarg6; + arg7 = (unsigned int)jarg7; + arg8 = (unsigned int)jarg8; + arg9 = (unsigned int)jarg9; + arg10 = (unsigned int)jarg10; + arg11 = *(SCIP_Result **)&jarg11; + result = (SCIP_RETCODE)(arg1)->scip_check(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11); + jresult = (jint)result; return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createExprProduct(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2, jlong jarg3, jdouble jarg4) { - jlong jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - int arg2 ; - SCIP_EXPR **arg3 = (SCIP_EXPR **) 0 ; - double arg4 ; - SCIP_EXPR *result = 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1checkSwigExplicitObjConshdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jint jarg5, jlong jarg6, jlong jarg7, jlong jarg8, jlong jarg9, jlong jarg10, jlong jarg11) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS **arg4 = (SCIP_CONS **) 0 ; + int arg5 ; + SCIP_SOL *arg6 = (SCIP_SOL *) 0 ; + unsigned int arg7 ; + unsigned int arg8 ; + unsigned int arg9 ; + unsigned int arg10 ; + SCIP_Result *arg11 = (SCIP_Result *) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = (int)jarg2; - arg3 = *(SCIP_EXPR ***)&jarg3; - arg4 = (double)jarg4; - result = (SCIP_EXPR *)createExprProduct(arg1,arg2,arg3,arg4); - *(SCIP_EXPR **)&jresult = result; + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS ***)&jarg4; + arg5 = (int)jarg5; + arg6 = *(SCIP_SOL **)&jarg6; + arg7 = (unsigned int)jarg7; + arg8 = (unsigned int)jarg8; + arg9 = (unsigned int)jarg9; + arg10 = (unsigned int)jarg10; + arg11 = *(SCIP_Result **)&jarg11; + result = (SCIP_RETCODE)(arg1)->scip::ObjConshdlr::scip_check(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11); + jresult = (jint)result; return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createExprSum(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2, jlong jarg3, jlong jarg4, jdouble jarg5) { - jlong jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - int arg2 ; - SCIP_EXPR **arg3 = (SCIP_EXPR **) 0 ; - double *arg4 = (double *) 0 ; - double arg5 ; - SCIP_EXPR *result = 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1prop(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jint jarg5, jint jarg6, jint jarg7, jlong jarg8, jlong jarg9) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS **arg4 = (SCIP_CONS **) 0 ; + int arg5 ; + int arg6 ; + int arg7 ; + SCIP_PROPTIMING arg8 ; + SCIP_Result *arg9 = (SCIP_Result *) 0 ; + SCIP_PROPTIMING *argp8 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = (int)jarg2; - arg3 = *(SCIP_EXPR ***)&jarg3; - arg4 = *(double **)&jarg4; - arg5 = (double)jarg5; - result = (SCIP_EXPR *)createExprSum(arg1,arg2,arg3,arg4,arg5); - *(SCIP_EXPR **)&jresult = result; + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS ***)&jarg4; + arg5 = (int)jarg5; + arg6 = (int)jarg6; + arg7 = (int)jarg7; + argp8 = *(SCIP_PROPTIMING **)&jarg8; + if (!argp8) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null SCIP_PROPTIMING"); + return 0; + } + arg8 = *argp8; + arg9 = *(SCIP_Result **)&jarg9; + result = (SCIP_RETCODE)(arg1)->scip_prop(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + jresult = (jint)result; return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createExprSin(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { - jlong jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - SCIP_EXPR *arg2 = (SCIP_EXPR *) 0 ; - SCIP_EXPR *result = 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1propSwigExplicitObjConshdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jint jarg5, jint jarg6, jint jarg7, jlong jarg8, jlong jarg9) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS **arg4 = (SCIP_CONS **) 0 ; + int arg5 ; + int arg6 ; + int arg7 ; + SCIP_PROPTIMING arg8 ; + SCIP_Result *arg9 = (SCIP_Result *) 0 ; + SCIP_PROPTIMING *argp8 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = *(SCIP_EXPR **)&jarg2; - result = (SCIP_EXPR *)createExprSin(arg1,arg2); - *(SCIP_EXPR **)&jresult = result; + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS ***)&jarg4; + arg5 = (int)jarg5; + arg6 = (int)jarg6; + arg7 = (int)jarg7; + argp8 = *(SCIP_PROPTIMING **)&jarg8; + if (!argp8) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null SCIP_PROPTIMING"); + return 0; + } + arg8 = *argp8; + arg9 = *(SCIP_Result **)&jarg9; + result = (SCIP_RETCODE)(arg1)->scip::ObjConshdlr::scip_prop(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + jresult = (jint)result; return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createExprCos(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { - jlong jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - SCIP_EXPR *arg2 = (SCIP_EXPR *) 0 ; - SCIP_EXPR *result = 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1presol(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jint jarg5, jint jarg6, jlong jarg7, jint jarg8, jint jarg9, jint jarg10, jint jarg11, jint jarg12, jint jarg13, jint jarg14, jint jarg15, jint jarg16, jint jarg17, jlong jarg18, jlong jarg19, jlong jarg20, jlong jarg21, jlong jarg22, jlong jarg23, jlong jarg24, jlong jarg25, jlong jarg26, jlong jarg27, jlong jarg28) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS **arg4 = (SCIP_CONS **) 0 ; + int arg5 ; + int arg6 ; + SCIP_PRESOLTIMING arg7 ; + int arg8 ; + int arg9 ; + int arg10 ; + int arg11 ; + int arg12 ; + int arg13 ; + int arg14 ; + int arg15 ; + int arg16 ; + int arg17 ; + int *arg18 = (int *) 0 ; + int *arg19 = (int *) 0 ; + int *arg20 = (int *) 0 ; + int *arg21 = (int *) 0 ; + int *arg22 = (int *) 0 ; + int *arg23 = (int *) 0 ; + int *arg24 = (int *) 0 ; + int *arg25 = (int *) 0 ; + int *arg26 = (int *) 0 ; + int *arg27 = (int *) 0 ; + SCIP_Result *arg28 = (SCIP_Result *) 0 ; + SCIP_PRESOLTIMING *argp7 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = *(SCIP_EXPR **)&jarg2; - result = (SCIP_EXPR *)createExprCos(arg1,arg2); - *(SCIP_EXPR **)&jresult = result; + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS ***)&jarg4; + arg5 = (int)jarg5; + arg6 = (int)jarg6; + argp7 = *(SCIP_PRESOLTIMING **)&jarg7; + if (!argp7) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null SCIP_PRESOLTIMING"); + return 0; + } + arg7 = *argp7; + arg8 = (int)jarg8; + arg9 = (int)jarg9; + arg10 = (int)jarg10; + arg11 = (int)jarg11; + arg12 = (int)jarg12; + arg13 = (int)jarg13; + arg14 = (int)jarg14; + arg15 = (int)jarg15; + arg16 = (int)jarg16; + arg17 = (int)jarg17; + arg18 = *(int **)&jarg18; + arg19 = *(int **)&jarg19; + arg20 = *(int **)&jarg20; + arg21 = *(int **)&jarg21; + arg22 = *(int **)&jarg22; + arg23 = *(int **)&jarg23; + arg24 = *(int **)&jarg24; + arg25 = *(int **)&jarg25; + arg26 = *(int **)&jarg26; + arg27 = *(int **)&jarg27; + arg28 = *(SCIP_Result **)&jarg28; + result = (SCIP_RETCODE)(arg1)->scip_presol(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22,arg23,arg24,arg25,arg26,arg27,arg28); + jresult = (jint)result; return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createExprValue(JNIEnv *jenv, jclass jcls, jlong jarg1, jdouble jarg2) { - jlong jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - double arg2 ; - SCIP_EXPR *result = 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1presolSwigExplicitObjConshdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jint jarg5, jint jarg6, jlong jarg7, jint jarg8, jint jarg9, jint jarg10, jint jarg11, jint jarg12, jint jarg13, jint jarg14, jint jarg15, jint jarg16, jint jarg17, jlong jarg18, jlong jarg19, jlong jarg20, jlong jarg21, jlong jarg22, jlong jarg23, jlong jarg24, jlong jarg25, jlong jarg26, jlong jarg27, jlong jarg28) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS **arg4 = (SCIP_CONS **) 0 ; + int arg5 ; + int arg6 ; + SCIP_PRESOLTIMING arg7 ; + int arg8 ; + int arg9 ; + int arg10 ; + int arg11 ; + int arg12 ; + int arg13 ; + int arg14 ; + int arg15 ; + int arg16 ; + int arg17 ; + int *arg18 = (int *) 0 ; + int *arg19 = (int *) 0 ; + int *arg20 = (int *) 0 ; + int *arg21 = (int *) 0 ; + int *arg22 = (int *) 0 ; + int *arg23 = (int *) 0 ; + int *arg24 = (int *) 0 ; + int *arg25 = (int *) 0 ; + int *arg26 = (int *) 0 ; + int *arg27 = (int *) 0 ; + SCIP_Result *arg28 = (SCIP_Result *) 0 ; + SCIP_PRESOLTIMING *argp7 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = (double)jarg2; - result = (SCIP_EXPR *)createExprValue(arg1,arg2); - *(SCIP_EXPR **)&jresult = result; + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS ***)&jarg4; + arg5 = (int)jarg5; + arg6 = (int)jarg6; + argp7 = *(SCIP_PRESOLTIMING **)&jarg7; + if (!argp7) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null SCIP_PRESOLTIMING"); + return 0; + } + arg7 = *argp7; + arg8 = (int)jarg8; + arg9 = (int)jarg9; + arg10 = (int)jarg10; + arg11 = (int)jarg11; + arg12 = (int)jarg12; + arg13 = (int)jarg13; + arg14 = (int)jarg14; + arg15 = (int)jarg15; + arg16 = (int)jarg16; + arg17 = (int)jarg17; + arg18 = *(int **)&jarg18; + arg19 = *(int **)&jarg19; + arg20 = *(int **)&jarg20; + arg21 = *(int **)&jarg21; + arg22 = *(int **)&jarg22; + arg23 = *(int **)&jarg23; + arg24 = *(int **)&jarg24; + arg25 = *(int **)&jarg25; + arg26 = *(int **)&jarg26; + arg27 = *(int **)&jarg27; + arg28 = *(SCIP_Result **)&jarg28; + result = (SCIP_RETCODE)(arg1)->scip::ObjConshdlr::scip_presol(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22,arg23,arg24,arg25,arg26,arg27,arg28); + jresult = (jint)result; return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createExprVar(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { - jlong jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - SCIP_VAR *arg2 = (SCIP_VAR *) 0 ; - SCIP_EXPR *result = 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1resprop(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jlong jarg5, jint jarg6, jint jarg7, jlong jarg8, jdouble jarg9, jlong jarg10) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS *arg4 = (SCIP_CONS *) 0 ; + SCIP_VAR *arg5 = (SCIP_VAR *) 0 ; + int arg6 ; + SCIP_BOUNDTYPE arg7 ; + SCIP_BDCHGIDX *arg8 = (SCIP_BDCHGIDX *) 0 ; + double arg9 ; + SCIP_Result *arg10 = (SCIP_Result *) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = *(SCIP_VAR **)&jarg2; - result = (SCIP_EXPR *)createExprVar(arg1,arg2); - *(SCIP_EXPR **)&jresult = result; + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS **)&jarg4; + arg5 = *(SCIP_VAR **)&jarg5; + arg6 = (int)jarg6; + arg7 = (SCIP_BOUNDTYPE)jarg7; + arg8 = *(SCIP_BDCHGIDX **)&jarg8; + arg9 = (double)jarg9; + arg10 = *(SCIP_Result **)&jarg10; + result = (SCIP_RETCODE)(arg1)->scip_resprop(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); + jresult = (jint)result; return jresult; } - - -SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_releaseExpr(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { - SCIP *arg1 = (SCIP *) 0 ; - SCIP_EXPR *arg2 = (SCIP_EXPR *) 0 ; + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1respropSwigExplicitObjConshdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jlong jarg5, jint jarg6, jint jarg7, jlong jarg8, jdouble jarg9, jlong jarg10) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS *arg4 = (SCIP_CONS *) 0 ; + SCIP_VAR *arg5 = (SCIP_VAR *) 0 ; + int arg6 ; + SCIP_BOUNDTYPE arg7 ; + SCIP_BDCHGIDX *arg8 = (SCIP_BDCHGIDX *) 0 ; + double arg9 ; + SCIP_Result *arg10 = (SCIP_Result *) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = *(SCIP_EXPR **)&jarg2; - releaseExpr(arg1,arg2); + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS **)&jarg4; + arg5 = *(SCIP_VAR **)&jarg5; + arg6 = (int)jarg6; + arg7 = (SCIP_BOUNDTYPE)jarg7; + arg8 = *(SCIP_BDCHGIDX **)&jarg8; + arg9 = (double)jarg9; + arg10 = *(SCIP_Result **)&jarg10; + result = (SCIP_RETCODE)(arg1)->scip::ObjConshdlr::scip_resprop(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); + jresult = (jint)result; + return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicLinear(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jint jarg3, jlong jarg4, jlong jarg5, jdouble jarg6, jdouble jarg7) { - jlong jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - char *arg2 = (char *) 0 ; - int arg3 ; - SCIP_VAR **arg4 = (SCIP_VAR **) 0 ; - double *arg5 = (double *) 0 ; - double arg6 ; - double arg7 ; - SCIP_CONS *result = 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1lock(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jint jarg5, jint jarg6, jint jarg7) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS *arg4 = (SCIP_CONS *) 0 ; + SCIP_LockType arg5 ; + int arg6 ; + int arg7 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = 0; - if (jarg2) { - arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return 0; - } - arg3 = (int)jarg3; - arg4 = *(SCIP_VAR ***)&jarg4; - arg5 = *(double **)&jarg5; - arg6 = (double)jarg6; - arg7 = (double)jarg7; - result = (SCIP_CONS *)createConsBasicLinear(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7); - *(SCIP_CONS **)&jresult = result; - if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS **)&jarg4; + arg5 = (SCIP_LockType)jarg5; + arg6 = (int)jarg6; + arg7 = (int)jarg7; + result = (SCIP_RETCODE)(arg1)->scip_lock(arg2,arg3,arg4,arg5,arg6,arg7); + jresult = (jint)result; return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicQuadratic(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jint jarg3, jlong jarg4, jlong jarg5, jint jarg6, jlong jarg7, jlong jarg8, jlong jarg9, jdouble jarg10, jdouble jarg11) { - jlong jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - char *arg2 = (char *) 0 ; - int arg3 ; - SCIP_VAR **arg4 = (SCIP_VAR **) 0 ; - double *arg5 = (double *) 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1lockSwigExplicitObjConshdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jint jarg5, jint jarg6, jint jarg7) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS *arg4 = (SCIP_CONS *) 0 ; + SCIP_LockType arg5 ; int arg6 ; - SCIP_VAR **arg7 = (SCIP_VAR **) 0 ; - SCIP_VAR **arg8 = (SCIP_VAR **) 0 ; - double *arg9 = (double *) 0 ; - double arg10 ; - double arg11 ; - SCIP_CONS *result = 0 ; + int arg7 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = 0; - if (jarg2) { - arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return 0; - } - arg3 = (int)jarg3; - arg4 = *(SCIP_VAR ***)&jarg4; - arg5 = *(double **)&jarg5; + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS **)&jarg4; + arg5 = (SCIP_LockType)jarg5; arg6 = (int)jarg6; - arg7 = *(SCIP_VAR ***)&jarg7; - arg8 = *(SCIP_VAR ***)&jarg8; - arg9 = *(double **)&jarg9; - arg10 = (double)jarg10; - arg11 = (double)jarg11; - result = (SCIP_CONS *)createConsBasicQuadratic(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11); - *(SCIP_CONS **)&jresult = result; - if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + arg7 = (int)jarg7; + result = (SCIP_RETCODE)(arg1)->scip::ObjConshdlr::scip_lock(arg2,arg3,arg4,arg5,arg6,arg7); + jresult = (jint)result; return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicNonlinear(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3, jdouble jarg4, jdouble jarg5) { - jlong jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - char *arg2 = (char *) 0 ; - SCIP_EXPR *arg3 = (SCIP_EXPR *) 0 ; - double arg4 ; - double arg5 ; - SCIP_CONS *result = 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1active(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS *arg4 = (SCIP_CONS *) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = 0; - if (jarg2) { - arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return 0; - } - arg3 = *(SCIP_EXPR **)&jarg3; - arg4 = (double)jarg4; - arg5 = (double)jarg5; - result = (SCIP_CONS *)createConsBasicNonlinear(arg1,(char const *)arg2,arg3,arg4,arg5); - *(SCIP_CONS **)&jresult = result; - if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS **)&jarg4; + result = (SCIP_RETCODE)(arg1)->scip_active(arg2,arg3,arg4); + jresult = (jint)result; return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicSuperindicator(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3, jlong jarg4) { - jlong jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - char *arg2 = (char *) 0 ; - SCIP_VAR *arg3 = (SCIP_VAR *) 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1activeSwigExplicitObjConshdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; SCIP_CONS *arg4 = (SCIP_CONS *) 0 ; - SCIP_CONS *result = 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = 0; - if (jarg2) { - arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return 0; - } - arg3 = *(SCIP_VAR **)&jarg3; + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; arg4 = *(SCIP_CONS **)&jarg4; - result = (SCIP_CONS *)createConsBasicSuperindicator(arg1,(char const *)arg2,arg3,arg4); - *(SCIP_CONS **)&jresult = result; - if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + result = (SCIP_RETCODE)(arg1)->scip::ObjConshdlr::scip_active(arg2,arg3,arg4); + jresult = (jint)result; return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicPseudoboolean(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3, jint jarg4, jlong jarg5, jlong jarg6, jint jarg7, jlong jarg8, jlong jarg9, jlong jarg10, jdouble jarg11, jlong jarg12, jlong jarg13, jdouble jarg14, jdouble jarg15) { - jlong jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - char *arg2 = (char *) 0 ; - SCIP_VAR **arg3 = (SCIP_VAR **) 0 ; - int arg4 ; - double *arg5 = (double *) 0 ; - SCIP_VAR ***arg6 = (SCIP_VAR ***) 0 ; - int arg7 ; - int *arg8 = (int *) 0 ; - double *arg9 = (double *) 0 ; - SCIP_VAR *arg10 = (SCIP_VAR *) 0 ; - double arg11 ; - unsigned int arg12 ; - SCIP_VAR *arg13 = (SCIP_VAR *) 0 ; - double arg14 ; - double arg15 ; - SCIP_CONS *result = 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1deactive(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS *arg4 = (SCIP_CONS *) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = 0; - if (jarg2) { - arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return 0; - } - arg3 = *(SCIP_VAR ***)&jarg3; - arg4 = (int)jarg4; - arg5 = *(double **)&jarg5; - arg6 = *(SCIP_VAR ****)&jarg6; - arg7 = (int)jarg7; - arg8 = *(int **)&jarg8; - arg9 = *(double **)&jarg9; - arg10 = *(SCIP_VAR **)&jarg10; - arg11 = (double)jarg11; - arg12 = (unsigned int)jarg12; - arg13 = *(SCIP_VAR **)&jarg13; - arg14 = (double)jarg14; - arg15 = (double)jarg15; - result = (SCIP_CONS *)createConsBasicPseudoboolean(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15); - *(SCIP_CONS **)&jresult = result; - if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS **)&jarg4; + result = (SCIP_RETCODE)(arg1)->scip_deactive(arg2,arg3,arg4); + jresult = (jint)result; return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicSetpart(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jint jarg3, jlong jarg4) { - jlong jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - char *arg2 = (char *) 0 ; - int arg3 ; - SCIP_VAR **arg4 = (SCIP_VAR **) 0 ; - SCIP_CONS *result = 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1deactiveSwigExplicitObjConshdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS *arg4 = (SCIP_CONS *) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = 0; - if (jarg2) { - arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return 0; - } - arg3 = (int)jarg3; - arg4 = *(SCIP_VAR ***)&jarg4; - result = (SCIP_CONS *)createConsBasicSetpart(arg1,(char const *)arg2,arg3,arg4); - *(SCIP_CONS **)&jresult = result; - if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS **)&jarg4; + result = (SCIP_RETCODE)(arg1)->scip::ObjConshdlr::scip_deactive(arg2,arg3,arg4); + jresult = (jint)result; return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicSetpack(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jint jarg3, jlong jarg4) { - jlong jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - char *arg2 = (char *) 0 ; - int arg3 ; - SCIP_VAR **arg4 = (SCIP_VAR **) 0 ; - SCIP_CONS *result = 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1enable(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS *arg4 = (SCIP_CONS *) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = 0; - if (jarg2) { - arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return 0; - } - arg3 = (int)jarg3; - arg4 = *(SCIP_VAR ***)&jarg4; - result = (SCIP_CONS *)createConsBasicSetpack(arg1,(char const *)arg2,arg3,arg4); - *(SCIP_CONS **)&jresult = result; - if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS **)&jarg4; + result = (SCIP_RETCODE)(arg1)->scip_enable(arg2,arg3,arg4); + jresult = (jint)result; return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicSetcover(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jint jarg3, jlong jarg4) { - jlong jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - char *arg2 = (char *) 0 ; - int arg3 ; - SCIP_VAR **arg4 = (SCIP_VAR **) 0 ; - SCIP_CONS *result = 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1enableSwigExplicitObjConshdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS *arg4 = (SCIP_CONS *) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = 0; - if (jarg2) { - arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return 0; - } - arg3 = (int)jarg3; - arg4 = *(SCIP_VAR ***)&jarg4; - result = (SCIP_CONS *)createConsBasicSetcover(arg1,(char const *)arg2,arg3,arg4); - *(SCIP_CONS **)&jresult = result; - if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS **)&jarg4; + result = (SCIP_RETCODE)(arg1)->scip::ObjConshdlr::scip_enable(arg2,arg3,arg4); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1disable(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS *arg4 = (SCIP_CONS *) 0 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS **)&jarg4; + result = (SCIP_RETCODE)(arg1)->scip_disable(arg2,arg3,arg4); + jresult = (jint)result; return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicSOC(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jint jarg3, jlong jarg4, jlong jarg5, jlong jarg6, jdouble jarg7, jlong jarg8, jdouble jarg9, jdouble jarg10) { - jlong jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - char *arg2 = (char *) 0 ; - int arg3 ; - SCIP_VAR **arg4 = (SCIP_VAR **) 0 ; - double *arg5 = (double *) 0 ; - double *arg6 = (double *) 0 ; - double arg7 ; - SCIP_VAR *arg8 = (SCIP_VAR *) 0 ; - double arg9 ; - double arg10 ; - SCIP_CONS *result = 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1disableSwigExplicitObjConshdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS *arg4 = (SCIP_CONS *) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = 0; - if (jarg2) { - arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return 0; - } - arg3 = (int)jarg3; - arg4 = *(SCIP_VAR ***)&jarg4; - arg5 = *(double **)&jarg5; - arg6 = *(double **)&jarg6; - arg7 = (double)jarg7; - arg8 = *(SCIP_VAR **)&jarg8; - arg9 = (double)jarg9; - arg10 = (double)jarg10; - result = (SCIP_CONS *)createConsBasicSOC(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); - *(SCIP_CONS **)&jresult = result; - if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS **)&jarg4; + result = (SCIP_RETCODE)(arg1)->scip::ObjConshdlr::scip_disable(arg2,arg3,arg4); + jresult = (jint)result; return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicSignpower(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3, jlong jarg4, jdouble jarg5, jdouble jarg6, jdouble jarg7, jdouble jarg8, jdouble jarg9) { - jlong jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - char *arg2 = (char *) 0 ; - SCIP_VAR *arg3 = (SCIP_VAR *) 0 ; - SCIP_VAR *arg4 = (SCIP_VAR *) 0 ; - double arg5 ; - double arg6 ; - double arg7 ; - double arg8 ; - double arg9 ; - SCIP_CONS *result = 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1delvars(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jint jarg5) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS **arg4 = (SCIP_CONS **) 0 ; + int arg5 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = 0; - if (jarg2) { - arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return 0; - } - arg3 = *(SCIP_VAR **)&jarg3; - arg4 = *(SCIP_VAR **)&jarg4; - arg5 = (double)jarg5; - arg6 = (double)jarg6; - arg7 = (double)jarg7; - arg8 = (double)jarg8; - arg9 = (double)jarg9; - result = (SCIP_CONS *)createConsBasicSignpower(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); - *(SCIP_CONS **)&jresult = result; - if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS ***)&jarg4; + arg5 = (int)jarg5; + result = (SCIP_RETCODE)(arg1)->scip_delvars(arg2,arg3,arg4,arg5); + jresult = (jint)result; return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicAnd(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3, jint jarg4, jlong jarg5) { - jlong jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - char *arg2 = (char *) 0 ; - SCIP_VAR *arg3 = (SCIP_VAR *) 0 ; - int arg4 ; - SCIP_VAR **arg5 = (SCIP_VAR **) 0 ; - SCIP_CONS *result = 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1delvarsSwigExplicitObjConshdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jint jarg5) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS **arg4 = (SCIP_CONS **) 0 ; + int arg5 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = 0; - if (jarg2) { - arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return 0; - } - arg3 = *(SCIP_VAR **)&jarg3; - arg4 = (int)jarg4; - arg5 = *(SCIP_VAR ***)&jarg5; - result = (SCIP_CONS *)createConsBasicAnd(arg1,(char const *)arg2,arg3,arg4,arg5); - *(SCIP_CONS **)&jresult = result; - if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS ***)&jarg4; + arg5 = (int)jarg5; + result = (SCIP_RETCODE)(arg1)->scip::ObjConshdlr::scip_delvars(arg2,arg3,arg4,arg5); + jresult = (jint)result; return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicOr(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3, jint jarg4, jlong jarg5) { - jlong jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - char *arg2 = (char *) 0 ; - SCIP_VAR *arg3 = (SCIP_VAR *) 0 ; - int arg4 ; - SCIP_VAR **arg5 = (SCIP_VAR **) 0 ; - SCIP_CONS *result = 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1print(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jlong jarg5) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS *arg4 = (SCIP_CONS *) 0 ; + FILE *arg5 = (FILE *) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = 0; - if (jarg2) { - arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return 0; - } - arg3 = *(SCIP_VAR **)&jarg3; - arg4 = (int)jarg4; - arg5 = *(SCIP_VAR ***)&jarg5; - result = (SCIP_CONS *)createConsBasicOr(arg1,(char const *)arg2,arg3,arg4,arg5); - *(SCIP_CONS **)&jresult = result; - if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS **)&jarg4; + arg5 = *(FILE **)&jarg5; + result = (SCIP_RETCODE)(arg1)->scip_print(arg2,arg3,arg4,arg5); + jresult = (jint)result; return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicBounddisjunction(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jint jarg3, jlong jarg4, jlong jarg5, jlong jarg6) { - jlong jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - char *arg2 = (char *) 0 ; - int arg3 ; - SCIP_VAR **arg4 = (SCIP_VAR **) 0 ; - SCIP_BOUNDTYPE *arg5 = (SCIP_BOUNDTYPE *) 0 ; - double *arg6 = (double *) 0 ; - SCIP_CONS *result = 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1printSwigExplicitObjConshdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jlong jarg5) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS *arg4 = (SCIP_CONS *) 0 ; + FILE *arg5 = (FILE *) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = 0; - if (jarg2) { - arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return 0; - } - arg3 = (int)jarg3; - arg4 = *(SCIP_VAR ***)&jarg4; - arg5 = *(SCIP_BOUNDTYPE **)&jarg5; - arg6 = *(double **)&jarg6; - result = (SCIP_CONS *)createConsBasicBounddisjunction(arg1,(char const *)arg2,arg3,arg4,arg5,arg6); - *(SCIP_CONS **)&jresult = result; - if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS **)&jarg4; + arg5 = *(FILE **)&jarg5; + result = (SCIP_RETCODE)(arg1)->scip::ObjConshdlr::scip_print(arg2,arg3,arg4,arg5); + jresult = (jint)result; return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicBounddisjunctionRedundant(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jint jarg3, jlong jarg4, jlong jarg5, jlong jarg6) { - jlong jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - char *arg2 = (char *) 0 ; - int arg3 ; - SCIP_VAR **arg4 = (SCIP_VAR **) 0 ; - SCIP_BOUNDTYPE *arg5 = (SCIP_BOUNDTYPE *) 0 ; - double *arg6 = (double *) 0 ; - SCIP_CONS *result = 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1copy(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jstring jarg4, jlong jarg5, jlong jarg6, jlong jarg7, jlong jarg8, jlong jarg9, jlong jarg10, jlong jarg11, jlong jarg12, jlong jarg13, jlong jarg14, jlong jarg15, jlong jarg16, jlong jarg17, jlong jarg18, jlong jarg19, jlong jarg20, jlong jarg21) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONS **arg3 = (SCIP_CONS **) 0 ; + char *arg4 = (char *) 0 ; + SCIP *arg5 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg6 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS *arg7 = (SCIP_CONS *) 0 ; + SCIP_HASHMAP *arg8 = (SCIP_HASHMAP *) 0 ; + SCIP_HASHMAP *arg9 = (SCIP_HASHMAP *) 0 ; + unsigned int arg10 ; + unsigned int arg11 ; + unsigned int arg12 ; + unsigned int arg13 ; + unsigned int arg14 ; + unsigned int arg15 ; + unsigned int arg16 ; + unsigned int arg17 ; + unsigned int arg18 ; + unsigned int arg19 ; + unsigned int arg20 ; + unsigned int *arg21 = (unsigned int *) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = 0; - if (jarg2) { - arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return 0; + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONS ***)&jarg3; + arg4 = 0; + if (jarg4) { + arg4 = (char *)jenv->GetStringUTFChars(jarg4, 0); + if (!arg4) return 0; } - arg3 = (int)jarg3; - arg4 = *(SCIP_VAR ***)&jarg4; - arg5 = *(SCIP_BOUNDTYPE **)&jarg5; - arg6 = *(double **)&jarg6; - result = (SCIP_CONS *)createConsBasicBounddisjunctionRedundant(arg1,(char const *)arg2,arg3,arg4,arg5,arg6); - *(SCIP_CONS **)&jresult = result; - if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + arg5 = *(SCIP **)&jarg5; + arg6 = *(SCIP_CONSHDLR **)&jarg6; + arg7 = *(SCIP_CONS **)&jarg7; + arg8 = *(SCIP_HASHMAP **)&jarg8; + arg9 = *(SCIP_HASHMAP **)&jarg9; + arg10 = (unsigned int)jarg10; + arg11 = (unsigned int)jarg11; + arg12 = (unsigned int)jarg12; + arg13 = (unsigned int)jarg13; + arg14 = (unsigned int)jarg14; + arg15 = (unsigned int)jarg15; + arg16 = (unsigned int)jarg16; + arg17 = (unsigned int)jarg17; + arg18 = (unsigned int)jarg18; + arg19 = (unsigned int)jarg19; + arg20 = (unsigned int)jarg20; + arg21 = *(unsigned int **)&jarg21; + result = (SCIP_RETCODE)(arg1)->scip_copy(arg2,arg3,(char const *)arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21); + jresult = (jint)result; + if (arg4) jenv->ReleaseStringUTFChars(jarg4, (const char *)arg4); return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicCardinality(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jint jarg3, jlong jarg4, jint jarg5, jlong jarg6, jlong jarg7) { - jlong jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - char *arg2 = (char *) 0 ; - int arg3 ; - SCIP_VAR **arg4 = (SCIP_VAR **) 0 ; - int arg5 ; - SCIP_VAR **arg6 = (SCIP_VAR **) 0 ; - double *arg7 = (double *) 0 ; - SCIP_CONS *result = 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1copySwigExplicitObjConshdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jstring jarg4, jlong jarg5, jlong jarg6, jlong jarg7, jlong jarg8, jlong jarg9, jlong jarg10, jlong jarg11, jlong jarg12, jlong jarg13, jlong jarg14, jlong jarg15, jlong jarg16, jlong jarg17, jlong jarg18, jlong jarg19, jlong jarg20, jlong jarg21) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONS **arg3 = (SCIP_CONS **) 0 ; + char *arg4 = (char *) 0 ; + SCIP *arg5 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg6 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS *arg7 = (SCIP_CONS *) 0 ; + SCIP_HASHMAP *arg8 = (SCIP_HASHMAP *) 0 ; + SCIP_HASHMAP *arg9 = (SCIP_HASHMAP *) 0 ; + unsigned int arg10 ; + unsigned int arg11 ; + unsigned int arg12 ; + unsigned int arg13 ; + unsigned int arg14 ; + unsigned int arg15 ; + unsigned int arg16 ; + unsigned int arg17 ; + unsigned int arg18 ; + unsigned int arg19 ; + unsigned int arg20 ; + unsigned int *arg21 = (unsigned int *) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = 0; - if (jarg2) { - arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return 0; + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONS ***)&jarg3; + arg4 = 0; + if (jarg4) { + arg4 = (char *)jenv->GetStringUTFChars(jarg4, 0); + if (!arg4) return 0; } - arg3 = (int)jarg3; - arg4 = *(SCIP_VAR ***)&jarg4; - arg5 = (int)jarg5; - arg6 = *(SCIP_VAR ***)&jarg6; - arg7 = *(double **)&jarg7; - result = (SCIP_CONS *)createConsBasicCardinality(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7); - *(SCIP_CONS **)&jresult = result; - if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + arg5 = *(SCIP **)&jarg5; + arg6 = *(SCIP_CONSHDLR **)&jarg6; + arg7 = *(SCIP_CONS **)&jarg7; + arg8 = *(SCIP_HASHMAP **)&jarg8; + arg9 = *(SCIP_HASHMAP **)&jarg9; + arg10 = (unsigned int)jarg10; + arg11 = (unsigned int)jarg11; + arg12 = (unsigned int)jarg12; + arg13 = (unsigned int)jarg13; + arg14 = (unsigned int)jarg14; + arg15 = (unsigned int)jarg15; + arg16 = (unsigned int)jarg16; + arg17 = (unsigned int)jarg17; + arg18 = (unsigned int)jarg18; + arg19 = (unsigned int)jarg19; + arg20 = (unsigned int)jarg20; + arg21 = *(unsigned int **)&jarg21; + result = (SCIP_RETCODE)(arg1)->scip::ObjConshdlr::scip_copy(arg2,arg3,(char const *)arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21); + jresult = (jint)result; + if (arg4) jenv->ReleaseStringUTFChars(jarg4, (const char *)arg4); return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicConjunction(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jint jarg3, jlong jarg4) { - jlong jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - char *arg2 = (char *) 0 ; - int arg3 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1parse(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jstring jarg5, jstring jarg6, jlong jarg7, jlong jarg8, jlong jarg9, jlong jarg10, jlong jarg11, jlong jarg12, jlong jarg13, jlong jarg14, jlong jarg15, jlong jarg16, jlong jarg17) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; SCIP_CONS **arg4 = (SCIP_CONS **) 0 ; - SCIP_CONS *result = 0 ; + char *arg5 = (char *) 0 ; + char *arg6 = (char *) 0 ; + unsigned int arg7 ; + unsigned int arg8 ; + unsigned int arg9 ; + unsigned int arg10 ; + unsigned int arg11 ; + unsigned int arg12 ; + unsigned int arg13 ; + unsigned int arg14 ; + unsigned int arg15 ; + unsigned int arg16 ; + unsigned int *arg17 = (unsigned int *) 0 ; + SCIP_RETCODE result; (void)jenv; - (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = 0; - if (jarg2) { - arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return 0; - } - arg3 = (int)jarg3; + (void)jcls; + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; arg4 = *(SCIP_CONS ***)&jarg4; - result = (SCIP_CONS *)createConsBasicConjunction(arg1,(char const *)arg2,arg3,arg4); - *(SCIP_CONS **)&jresult = result; - if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + arg5 = 0; + if (jarg5) { + arg5 = (char *)jenv->GetStringUTFChars(jarg5, 0); + if (!arg5) return 0; + } + arg6 = 0; + if (jarg6) { + arg6 = (char *)jenv->GetStringUTFChars(jarg6, 0); + if (!arg6) return 0; + } + arg7 = (unsigned int)jarg7; + arg8 = (unsigned int)jarg8; + arg9 = (unsigned int)jarg9; + arg10 = (unsigned int)jarg10; + arg11 = (unsigned int)jarg11; + arg12 = (unsigned int)jarg12; + arg13 = (unsigned int)jarg13; + arg14 = (unsigned int)jarg14; + arg15 = (unsigned int)jarg15; + arg16 = (unsigned int)jarg16; + arg17 = *(unsigned int **)&jarg17; + result = (SCIP_RETCODE)(arg1)->scip_parse(arg2,arg3,arg4,(char const *)arg5,(char const *)arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17); + jresult = (jint)result; + if (arg5) jenv->ReleaseStringUTFChars(jarg5, (const char *)arg5); + if (arg6) jenv->ReleaseStringUTFChars(jarg6, (const char *)arg6); return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicDisjunction(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jint jarg3, jlong jarg4, jlong jarg5) { - jlong jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - char *arg2 = (char *) 0 ; - int arg3 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1parseSwigExplicitObjConshdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jstring jarg5, jstring jarg6, jlong jarg7, jlong jarg8, jlong jarg9, jlong jarg10, jlong jarg11, jlong jarg12, jlong jarg13, jlong jarg14, jlong jarg15, jlong jarg16, jlong jarg17) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; SCIP_CONS **arg4 = (SCIP_CONS **) 0 ; - SCIP_CONS *arg5 = (SCIP_CONS *) 0 ; - SCIP_CONS *result = 0 ; + char *arg5 = (char *) 0 ; + char *arg6 = (char *) 0 ; + unsigned int arg7 ; + unsigned int arg8 ; + unsigned int arg9 ; + unsigned int arg10 ; + unsigned int arg11 ; + unsigned int arg12 ; + unsigned int arg13 ; + unsigned int arg14 ; + unsigned int arg15 ; + unsigned int arg16 ; + unsigned int *arg17 = (unsigned int *) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = 0; - if (jarg2) { - arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return 0; - } - arg3 = (int)jarg3; + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; arg4 = *(SCIP_CONS ***)&jarg4; - arg5 = *(SCIP_CONS **)&jarg5; - result = (SCIP_CONS *)createConsBasicDisjunction(arg1,(char const *)arg2,arg3,arg4,arg5); - *(SCIP_CONS **)&jresult = result; - if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + arg5 = 0; + if (jarg5) { + arg5 = (char *)jenv->GetStringUTFChars(jarg5, 0); + if (!arg5) return 0; + } + arg6 = 0; + if (jarg6) { + arg6 = (char *)jenv->GetStringUTFChars(jarg6, 0); + if (!arg6) return 0; + } + arg7 = (unsigned int)jarg7; + arg8 = (unsigned int)jarg8; + arg9 = (unsigned int)jarg9; + arg10 = (unsigned int)jarg10; + arg11 = (unsigned int)jarg11; + arg12 = (unsigned int)jarg12; + arg13 = (unsigned int)jarg13; + arg14 = (unsigned int)jarg14; + arg15 = (unsigned int)jarg15; + arg16 = (unsigned int)jarg16; + arg17 = *(unsigned int **)&jarg17; + result = (SCIP_RETCODE)(arg1)->scip::ObjConshdlr::scip_parse(arg2,arg3,arg4,(char const *)arg5,(char const *)arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17); + jresult = (jint)result; + if (arg5) jenv->ReleaseStringUTFChars(jarg5, (const char *)arg5); + if (arg6) jenv->ReleaseStringUTFChars(jarg6, (const char *)arg6); return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicCumulative(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jint jarg3, jlong jarg4, jlong jarg5, jlong jarg6, jint jarg7) { - jlong jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - char *arg2 = (char *) 0 ; - int arg3 ; - SCIP_VAR **arg4 = (SCIP_VAR **) 0 ; - int *arg5 = (int *) 0 ; - int *arg6 = (int *) 0 ; - int arg7 ; - SCIP_CONS *result = 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1getvars(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jlong jarg5, jint jarg6, jlong jarg7) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS *arg4 = (SCIP_CONS *) 0 ; + SCIP_VAR **arg5 = (SCIP_VAR **) 0 ; + int arg6 ; + unsigned int *arg7 = (unsigned int *) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = 0; - if (jarg2) { - arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return 0; - } - arg3 = (int)jarg3; - arg4 = *(SCIP_VAR ***)&jarg4; - arg5 = *(int **)&jarg5; - arg6 = *(int **)&jarg6; - arg7 = (int)jarg7; - result = (SCIP_CONS *)createConsBasicCumulative(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7); - *(SCIP_CONS **)&jresult = result; - if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS **)&jarg4; + arg5 = *(SCIP_VAR ***)&jarg5; + arg6 = (int)jarg6; + arg7 = *(unsigned int **)&jarg7; + result = (SCIP_RETCODE)(arg1)->scip_getvars(arg2,arg3,arg4,arg5,arg6,arg7); + jresult = (jint)result; return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicIndicator(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3, jint jarg4, jlong jarg5, jlong jarg6, jdouble jarg7) { - jlong jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - char *arg2 = (char *) 0 ; - SCIP_VAR *arg3 = (SCIP_VAR *) 0 ; - int arg4 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1getvarsSwigExplicitObjConshdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jlong jarg5, jint jarg6, jlong jarg7) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS *arg4 = (SCIP_CONS *) 0 ; SCIP_VAR **arg5 = (SCIP_VAR **) 0 ; - double *arg6 = (double *) 0 ; - double arg7 ; - SCIP_CONS *result = 0 ; + int arg6 ; + unsigned int *arg7 = (unsigned int *) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = 0; - if (jarg2) { - arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return 0; - } - arg3 = *(SCIP_VAR **)&jarg3; - arg4 = (int)jarg4; + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS **)&jarg4; arg5 = *(SCIP_VAR ***)&jarg5; - arg6 = *(double **)&jarg6; - arg7 = (double)jarg7; - result = (SCIP_CONS *)createConsBasicIndicator(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7); - *(SCIP_CONS **)&jresult = result; - if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + arg6 = (int)jarg6; + arg7 = *(unsigned int **)&jarg7; + result = (SCIP_RETCODE)(arg1)->scip::ObjConshdlr::scip_getvars(arg2,arg3,arg4,arg5,arg6,arg7); + jresult = (jint)result; return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicIndicatorLinCons(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3, jlong jarg4, jlong jarg5) { - jlong jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - char *arg2 = (char *) 0 ; - SCIP_VAR *arg3 = (SCIP_VAR *) 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1getnvars(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jlong jarg5, jlong jarg6) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; SCIP_CONS *arg4 = (SCIP_CONS *) 0 ; - SCIP_VAR *arg5 = (SCIP_VAR *) 0 ; - SCIP_CONS *result = 0 ; + int *arg5 = (int *) 0 ; + unsigned int *arg6 = (unsigned int *) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = 0; - if (jarg2) { - arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return 0; - } - arg3 = *(SCIP_VAR **)&jarg3; + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; arg4 = *(SCIP_CONS **)&jarg4; - arg5 = *(SCIP_VAR **)&jarg5; - result = (SCIP_CONS *)createConsBasicIndicatorLinCons(arg1,(char const *)arg2,arg3,arg4,arg5); - *(SCIP_CONS **)&jresult = result; - if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + arg5 = *(int **)&jarg5; + arg6 = *(unsigned int **)&jarg6; + result = (SCIP_RETCODE)(arg1)->scip_getnvars(arg2,arg3,arg4,arg5,arg6); + jresult = (jint)result; return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicKnapsack(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jint jarg3, jlong jarg4, jlong jarg5, jlong jarg6) { - jlong jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - char *arg2 = (char *) 0 ; - int arg3 ; - SCIP_VAR **arg4 = (SCIP_VAR **) 0 ; - long long *arg5 = (long long *) 0 ; - long long arg6 ; - SCIP_CONS *result = 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1getnvarsSwigExplicitObjConshdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jlong jarg5, jlong jarg6) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS *arg4 = (SCIP_CONS *) 0 ; + int *arg5 = (int *) 0 ; + unsigned int *arg6 = (unsigned int *) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = 0; - if (jarg2) { - arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return 0; - } - arg3 = (int)jarg3; - arg4 = *(SCIP_VAR ***)&jarg4; - arg5 = *(long long **)&jarg5; - arg6 = (long long)jarg6; - result = (SCIP_CONS *)createConsBasicKnapsack(arg1,(char const *)arg2,arg3,arg4,arg5,arg6); - *(SCIP_CONS **)&jresult = result; - if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS **)&jarg4; + arg5 = *(int **)&jarg5; + arg6 = *(unsigned int **)&jarg6; + result = (SCIP_RETCODE)(arg1)->scip::ObjConshdlr::scip_getnvars(arg2,arg3,arg4,arg5,arg6); + jresult = (jint)result; return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicLinking(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3, jlong jarg4, jlong jarg5, jint jarg6) { - jlong jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - char *arg2 = (char *) 0 ; - SCIP_VAR *arg3 = (SCIP_VAR *) 0 ; - SCIP_VAR **arg4 = (SCIP_VAR **) 0 ; - double *arg5 = (double *) 0 ; - int arg6 ; - SCIP_CONS *result = 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1getdivebdchgs(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jlong jarg5, jlong jarg6, jlong jarg7) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_DIVESET *arg4 = (SCIP_DIVESET *) 0 ; + SCIP_SOL *arg5 = (SCIP_SOL *) 0 ; + unsigned int *arg6 = (unsigned int *) 0 ; + unsigned int *arg7 = (unsigned int *) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = 0; - if (jarg2) { - arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return 0; - } - arg3 = *(SCIP_VAR **)&jarg3; - arg4 = *(SCIP_VAR ***)&jarg4; - arg5 = *(double **)&jarg5; - arg6 = (int)jarg6; - result = (SCIP_CONS *)createConsBasicLinking(arg1,(char const *)arg2,arg3,arg4,arg5,arg6); - *(SCIP_CONS **)&jresult = result; - if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_DIVESET **)&jarg4; + arg5 = *(SCIP_SOL **)&jarg5; + arg6 = *(unsigned int **)&jarg6; + arg7 = *(unsigned int **)&jarg7; + result = (SCIP_RETCODE)(arg1)->scip_getdivebdchgs(arg2,arg3,arg4,arg5,arg6,arg7); + jresult = (jint)result; return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicLogicor(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jint jarg3, jlong jarg4) { - jlong jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - char *arg2 = (char *) 0 ; - int arg3 ; - SCIP_VAR **arg4 = (SCIP_VAR **) 0 ; - SCIP_CONS *result = 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1getdivebdchgsSwigExplicitObjConshdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jlong jarg5, jlong jarg6, jlong jarg7) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_DIVESET *arg4 = (SCIP_DIVESET *) 0 ; + SCIP_SOL *arg5 = (SCIP_SOL *) 0 ; + unsigned int *arg6 = (unsigned int *) 0 ; + unsigned int *arg7 = (unsigned int *) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = 0; - if (jarg2) { - arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return 0; - } - arg3 = (int)jarg3; - arg4 = *(SCIP_VAR ***)&jarg4; - result = (SCIP_CONS *)createConsBasicLogicor(arg1,(char const *)arg2,arg3,arg4); - *(SCIP_CONS **)&jresult = result; - if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_DIVESET **)&jarg4; + arg5 = *(SCIP_SOL **)&jarg5; + arg6 = *(unsigned int **)&jarg6; + arg7 = *(unsigned int **)&jarg7; + result = (SCIP_RETCODE)(arg1)->scip::ObjConshdlr::scip_getdivebdchgs(arg2,arg3,arg4,arg5,arg6,arg7); + jresult = (jint)result; return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicOrbisack(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3, jlong jarg4, jint jarg5, jlong jarg6, jlong jarg7, jlong jarg8) { - jlong jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - char *arg2 = (char *) 0 ; - SCIP_VAR **arg3 = (SCIP_VAR **) 0 ; - SCIP_VAR **arg4 = (SCIP_VAR **) 0 ; - int arg5 ; - unsigned int arg6 ; - unsigned int arg7 ; - unsigned int arg8 ; - SCIP_CONS *result = 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1getpermsymgraph(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jlong jarg5, jlong jarg6) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS *arg4 = (SCIP_CONS *) 0 ; + SYM_GRAPH *arg5 = (SYM_GRAPH *) 0 ; + unsigned int *arg6 = (unsigned int *) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = 0; - if (jarg2) { - arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return 0; - } - arg3 = *(SCIP_VAR ***)&jarg3; - arg4 = *(SCIP_VAR ***)&jarg4; - arg5 = (int)jarg5; - arg6 = (unsigned int)jarg6; - arg7 = (unsigned int)jarg7; - arg8 = (unsigned int)jarg8; - result = (SCIP_CONS *)createConsBasicOrbisack(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8); - *(SCIP_CONS **)&jresult = result; - if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS **)&jarg4; + arg5 = *(SYM_GRAPH **)&jarg5; + arg6 = *(unsigned int **)&jarg6; + result = (SCIP_RETCODE)(arg1)->scip_getpermsymgraph(arg2,arg3,arg4,arg5,arg6); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1getpermsymgraphSwigExplicitObjConshdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jlong jarg5, jlong jarg6) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS *arg4 = (SCIP_CONS *) 0 ; + SYM_GRAPH *arg5 = (SYM_GRAPH *) 0 ; + unsigned int *arg6 = (unsigned int *) 0 ; + SCIP_RETCODE result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS **)&jarg4; + arg5 = *(SYM_GRAPH **)&jarg5; + arg6 = *(unsigned int **)&jarg6; + result = (SCIP_RETCODE)(arg1)->scip::ObjConshdlr::scip_getpermsymgraph(arg2,arg3,arg4,arg5,arg6); + jresult = (jint)result; return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicOrbitope(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3, jint jarg4, jint jarg5, jint jarg6, jlong jarg7, jlong jarg8, jlong jarg9, jlong jarg10) { - jlong jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - char *arg2 = (char *) 0 ; - SCIP_VAR ***arg3 = (SCIP_VAR ***) 0 ; - SCIP_ORBITOPETYPE arg4 ; - int arg5 ; - int arg6 ; - unsigned int arg7 ; - unsigned int arg8 ; - unsigned int arg9 ; - unsigned int arg10 ; - SCIP_CONS *result = 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1getsignedpermsymgraph(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jlong jarg5, jlong jarg6) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS *arg4 = (SCIP_CONS *) 0 ; + SYM_GRAPH *arg5 = (SYM_GRAPH *) 0 ; + unsigned int *arg6 = (unsigned int *) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = 0; - if (jarg2) { - arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return 0; - } - arg3 = *(SCIP_VAR ****)&jarg3; - arg4 = (SCIP_ORBITOPETYPE)jarg4; - arg5 = (int)jarg5; - arg6 = (int)jarg6; - arg7 = (unsigned int)jarg7; - arg8 = (unsigned int)jarg8; - arg9 = (unsigned int)jarg9; - arg10 = (unsigned int)jarg10; - result = (SCIP_CONS *)createConsBasicOrbitope(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); - *(SCIP_CONS **)&jresult = result; - if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS **)&jarg4; + arg5 = *(SYM_GRAPH **)&jarg5; + arg6 = *(unsigned int **)&jarg6; + result = (SCIP_RETCODE)(arg1)->scip_getsignedpermsymgraph(arg2,arg3,arg4,arg5,arg6); + jresult = (jint)result; return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicSOS1(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jint jarg3, jlong jarg4, jlong jarg5) { - jlong jresult = 0 ; - SCIP *arg1 = (SCIP *) 0 ; - char *arg2 = (char *) 0 ; - int arg3 ; - SCIP_VAR **arg4 = (SCIP_VAR **) 0 ; - double *arg5 = (double *) 0 ; - SCIP_CONS *result = 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1scip_1getsignedpermsymgraphSwigExplicitObjConshdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jlong jarg5, jlong jarg6) { + jint jresult = 0 ; + scip::ObjConshdlr *arg1 = (scip::ObjConshdlr *) 0 ; + SCIP *arg2 = (SCIP *) 0 ; + SCIP_CONSHDLR *arg3 = (SCIP_CONSHDLR *) 0 ; + SCIP_CONS *arg4 = (SCIP_CONS *) 0 ; + SYM_GRAPH *arg5 = (SYM_GRAPH *) 0 ; + unsigned int *arg6 = (unsigned int *) 0 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; - arg1 = *(SCIP **)&jarg1; - arg2 = 0; - if (jarg2) { - arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return 0; - } - arg3 = (int)jarg3; - arg4 = *(SCIP_VAR ***)&jarg4; - arg5 = *(double **)&jarg5; - result = (SCIP_CONS *)createConsBasicSOS1(arg1,(char const *)arg2,arg3,arg4,arg5); - *(SCIP_CONS **)&jresult = result; - if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + (void)jarg1_; + arg1 = *(scip::ObjConshdlr **)&jarg1; + arg2 = *(SCIP **)&jarg2; + arg3 = *(SCIP_CONSHDLR **)&jarg3; + arg4 = *(SCIP_CONS **)&jarg4; + arg5 = *(SYM_GRAPH **)&jarg5; + arg6 = *(unsigned int **)&jarg6; + result = (SCIP_RETCODE)(arg1)->scip::ObjConshdlr::scip_getsignedpermsymgraph(arg2,arg3,arg4,arg5,arg6); + jresult = (jint)result; return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicSOS2(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jint jarg3, jlong jarg4, jlong jarg5) { - jlong jresult = 0 ; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1director_1connect(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jswig_mem_own, jboolean jweak_global) { + scip::ObjConshdlr *obj = *((scip::ObjConshdlr **)&objarg); + (void)jcls; + SwigDirector_ObjConshdlr *director = static_cast(obj); + director->swig_connect_director(jenv, jself, jenv->GetObjectClass(jself), (jswig_mem_own == JNI_TRUE), (jweak_global == JNI_TRUE)); +} + + +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_ObjConshdlr_1change_1ownership(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jtake_or_release) { + scip::ObjConshdlr *obj = *((scip::ObjConshdlr **)&objarg); + SwigDirector_ObjConshdlr *director = dynamic_cast(obj); + (void)jcls; + if (director) { + director->swig_java_change_ownership(jenv, jself, jtake_or_release ? true : false); + } +} + + +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPincludeObjConshdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jobject jarg2_, jlong jarg3) { + jint jresult = 0 ; SCIP *arg1 = (SCIP *) 0 ; - char *arg2 = (char *) 0 ; - int arg3 ; - SCIP_VAR **arg4 = (SCIP_VAR **) 0 ; - double *arg5 = (double *) 0 ; - SCIP_CONS *result = 0 ; + scip::ObjConshdlr *arg2 = (scip::ObjConshdlr *) 0 ; + unsigned int arg3 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; + (void)jarg2_; arg1 = *(SCIP **)&jarg1; - arg2 = 0; - if (jarg2) { - arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return 0; - } - arg3 = (int)jarg3; - arg4 = *(SCIP_VAR ***)&jarg4; - arg5 = *(double **)&jarg5; - result = (SCIP_CONS *)createConsBasicSOS2(arg1,(char const *)arg2,arg3,arg4,arg5); - *(SCIP_CONS **)&jresult = result; - if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + arg2 = *(scip::ObjConshdlr **)&jarg2; + arg3 = (unsigned int)jarg3; + result = (SCIP_RETCODE)SCIPincludeObjConshdlr(arg1,arg2,arg3); + jresult = (jint)result; return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicSymresack(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3, jlong jarg4, jint jarg5, jlong jarg6) { +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIPfindObjConshdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2) { jlong jresult = 0 ; SCIP *arg1 = (SCIP *) 0 ; char *arg2 = (char *) 0 ; - int *arg3 = (int *) 0 ; - SCIP_VAR **arg4 = (SCIP_VAR **) 0 ; - int arg5 ; - unsigned int arg6 ; - SCIP_CONS *result = 0 ; + scip::ObjConshdlr *result = 0 ; (void)jenv; (void)jcls; @@ -6072,101 +12726,82 @@ SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicSymresack(JNIEnv * arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); if (!arg2) return 0; } - arg3 = *(int **)&jarg3; - arg4 = *(SCIP_VAR ***)&jarg4; - arg5 = (int)jarg5; - arg6 = (unsigned int)jarg6; - result = (SCIP_CONS *)createConsBasicSymresack(arg1,(char const *)arg2,arg3,arg4,arg5,arg6); - *(SCIP_CONS **)&jresult = result; + result = (scip::ObjConshdlr *)SCIPfindObjConshdlr(arg1,(char const *)arg2); + *(scip::ObjConshdlr **)&jresult = result; if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicVarbound(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3, jlong jarg4, jdouble jarg5, jdouble jarg6, jdouble jarg7) { +SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_SCIPgetObjConshdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { jlong jresult = 0 ; SCIP *arg1 = (SCIP *) 0 ; - char *arg2 = (char *) 0 ; - SCIP_VAR *arg3 = (SCIP_VAR *) 0 ; - SCIP_VAR *arg4 = (SCIP_VAR *) 0 ; - double arg5 ; - double arg6 ; - double arg7 ; - SCIP_CONS *result = 0 ; + SCIP_CONSHDLR *arg2 = (SCIP_CONSHDLR *) 0 ; + scip::ObjConshdlr *result = 0 ; (void)jenv; (void)jcls; arg1 = *(SCIP **)&jarg1; - arg2 = 0; - if (jarg2) { - arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return 0; - } - arg3 = *(SCIP_VAR **)&jarg3; - arg4 = *(SCIP_VAR **)&jarg4; - arg5 = (double)jarg5; - arg6 = (double)jarg6; - arg7 = (double)jarg7; - result = (SCIP_CONS *)createConsBasicVarbound(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7); - *(SCIP_CONS **)&jresult = result; - if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + arg2 = *(SCIP_CONSHDLR **)&jarg2; + result = (scip::ObjConshdlr *)SCIPgetObjConshdlr(arg1,arg2); + *(scip::ObjConshdlr **)&jresult = result; return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createConsBasicXor(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3, jint jarg4, jlong jarg5) { - jlong jresult = 0 ; +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPaddVarLocksType(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jint jarg3, jint jarg4, jint jarg5) { + jint jresult = 0 ; SCIP *arg1 = (SCIP *) 0 ; - char *arg2 = (char *) 0 ; - unsigned int arg3 ; + SCIP_VAR *arg2 = (SCIP_VAR *) 0 ; + SCIP_LockType arg3 ; int arg4 ; - SCIP_VAR **arg5 = (SCIP_VAR **) 0 ; - SCIP_CONS *result = 0 ; + int arg5 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; arg1 = *(SCIP **)&jarg1; - arg2 = 0; - if (jarg2) { - arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); - if (!arg2) return 0; - } - arg3 = (unsigned int)jarg3; + arg2 = *(SCIP_VAR **)&jarg2; + arg3 = (SCIP_LockType)jarg3; arg4 = (int)jarg4; - arg5 = *(SCIP_VAR ***)&jarg5; - result = (SCIP_CONS *)createConsBasicXor(arg1,(char const *)arg2,arg3,arg4,arg5); - *(SCIP_CONS **)&jresult = result; - if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + arg5 = (int)jarg5; + result = (SCIP_RETCODE)SCIPaddVarLocksType(arg1,arg2,arg3,arg4,arg5); + jresult = (jint)result; return jresult; } -SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_releaseCons(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { +SWIGEXPORT jint JNICALL Java_jscip_SCIPJNIJNI_SCIPaddConsLocksType(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jint jarg3, jint jarg4, jint jarg5) { + jint jresult = 0 ; SCIP *arg1 = (SCIP *) 0 ; SCIP_CONS *arg2 = (SCIP_CONS *) 0 ; + SCIP_LockType arg3 ; + int arg4 ; + int arg5 ; + SCIP_RETCODE result; (void)jenv; (void)jcls; arg1 = *(SCIP **)&jarg1; arg2 = *(SCIP_CONS **)&jarg2; - releaseCons(arg1,arg2); + arg3 = (SCIP_LockType)jarg3; + arg4 = (int)jarg4; + arg5 = (int)jarg5; + result = (SCIP_RETCODE)SCIPaddConsLocksType(arg1,arg2,arg3,arg4,arg5); + jresult = (jint)result; + return jresult; } -SWIGEXPORT jlong JNICALL Java_jscip_SCIPJNIJNI_createObjMessagehdlr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { - jlong jresult = 0 ; - scip::ObjMessagehdlr *arg1 = (scip::ObjMessagehdlr *) 0 ; - unsigned int arg2 ; - SCIP_MESSAGEHDLR *result = 0 ; +SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_setResult(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) { + SCIP_Result *arg1 = (SCIP_Result *) 0 ; + SCIP_Result arg2 ; (void)jenv; (void)jcls; - (void)jarg1_; - arg1 = *(scip::ObjMessagehdlr **)&jarg1; - arg2 = (unsigned int)jarg2; - result = (SCIP_MESSAGEHDLR *)createObjMessagehdlr(arg1,arg2); - *(SCIP_MESSAGEHDLR **)&jresult = result; - return jresult; + arg1 = *(SCIP_Result **)&jarg1; + arg2 = (SCIP_Result)jarg2; + setResult(arg1,arg2); } @@ -6176,7 +12811,7 @@ SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_swig_1module_1init(JNIEnv *jenv, j static struct { const char *method; const char *signature; - } methods[5] = { + } methods[45] = { { "SwigDirector_ObjMessagehdlr_scip_error", "(Ljscip/ObjMessagehdlr;JJLjava/lang/String;)V" }, @@ -6191,6 +12826,126 @@ SWIGEXPORT void JNICALL Java_jscip_SCIPJNIJNI_swig_1module_1init(JNIEnv *jenv, j }, { "SwigDirector_ObjMessagehdlr_scip_free", "(Ljscip/ObjMessagehdlr;J)I" + }, + { + "SwigDirector_ObjEventhdlr_scip_free", "(Ljscip/ObjEventhdlr;JJ)I" + }, + { + "SwigDirector_ObjEventhdlr_scip_init", "(Ljscip/ObjEventhdlr;JJ)I" + }, + { + "SwigDirector_ObjEventhdlr_scip_exit", "(Ljscip/ObjEventhdlr;JJ)I" + }, + { + "SwigDirector_ObjEventhdlr_scip_initsol", "(Ljscip/ObjEventhdlr;JJ)I" + }, + { + "SwigDirector_ObjEventhdlr_scip_exitsol", "(Ljscip/ObjEventhdlr;JJ)I" + }, + { + "SwigDirector_ObjEventhdlr_scip_delete", "(Ljscip/ObjEventhdlr;JJJ)I" + }, + { + "SwigDirector_ObjEventhdlr_scip_exec", "(Ljscip/ObjEventhdlr;JJJJ)I" + }, + { + "SwigDirector_ObjConshdlr_scip_free", "(Ljscip/ObjConshdlr;JJ)I" + }, + { + "SwigDirector_ObjConshdlr_scip_init", "(Ljscip/ObjConshdlr;JJJI)I" + }, + { + "SwigDirector_ObjConshdlr_scip_exit", "(Ljscip/ObjConshdlr;JJJI)I" + }, + { + "SwigDirector_ObjConshdlr_scip_initpre", "(Ljscip/ObjConshdlr;JJJI)I" + }, + { + "SwigDirector_ObjConshdlr_scip_exitpre", "(Ljscip/ObjConshdlr;JJJI)I" + }, + { + "SwigDirector_ObjConshdlr_scip_initsol", "(Ljscip/ObjConshdlr;JJJI)I" + }, + { + "SwigDirector_ObjConshdlr_scip_exitsol", "(Ljscip/ObjConshdlr;JJJIJ)I" + }, + { + "SwigDirector_ObjConshdlr_scip_delete", "(Ljscip/ObjConshdlr;JJJJ)I" + }, + { + "SwigDirector_ObjConshdlr_scip_trans", "(Ljscip/ObjConshdlr;JJJJ)I" + }, + { + "SwigDirector_ObjConshdlr_scip_initlp", "(Ljscip/ObjConshdlr;JJJIJ)I" + }, + { + "SwigDirector_ObjConshdlr_scip_sepalp", "(Ljscip/ObjConshdlr;JJJIIJ)I" + }, + { + "SwigDirector_ObjConshdlr_scip_sepasol", "(Ljscip/ObjConshdlr;JJJIIJJ)I" + }, + { + "SwigDirector_ObjConshdlr_scip_enfolp", "(Ljscip/ObjConshdlr;JJJIIJJ)I" + }, + { + "SwigDirector_ObjConshdlr_scip_enforelax", "(Ljscip/ObjConshdlr;JJJJIIJJ)I" + }, + { + "SwigDirector_ObjConshdlr_scip_enfops", "(Ljscip/ObjConshdlr;JJJIIJJJ)I" + }, + { + "SwigDirector_ObjConshdlr_scip_check", "(Ljscip/ObjConshdlr;JJJIJJJJJJ)I" + }, + { + "SwigDirector_ObjConshdlr_scip_prop", "(Ljscip/ObjConshdlr;JJJIIIJJ)I" + }, + { + "SwigDirector_ObjConshdlr_scip_presol", "(Ljscip/ObjConshdlr;JJJIIJIIIIIIIIIIJJJJJJJJJJJ)I" + }, + { + "SwigDirector_ObjConshdlr_scip_resprop", "(Ljscip/ObjConshdlr;JJJJIIJDJ)I" + }, + { + "SwigDirector_ObjConshdlr_scip_lock", "(Ljscip/ObjConshdlr;JJJIII)I" + }, + { + "SwigDirector_ObjConshdlr_scip_active", "(Ljscip/ObjConshdlr;JJJ)I" + }, + { + "SwigDirector_ObjConshdlr_scip_deactive", "(Ljscip/ObjConshdlr;JJJ)I" + }, + { + "SwigDirector_ObjConshdlr_scip_enable", "(Ljscip/ObjConshdlr;JJJ)I" + }, + { + "SwigDirector_ObjConshdlr_scip_disable", "(Ljscip/ObjConshdlr;JJJ)I" + }, + { + "SwigDirector_ObjConshdlr_scip_delvars", "(Ljscip/ObjConshdlr;JJJI)I" + }, + { + "SwigDirector_ObjConshdlr_scip_print", "(Ljscip/ObjConshdlr;JJJJ)I" + }, + { + "SwigDirector_ObjConshdlr_scip_copy", "(Ljscip/ObjConshdlr;JJLjava/lang/String;JJJJJJJJJJJJJJJJJ)I" + }, + { + "SwigDirector_ObjConshdlr_scip_parse", "(Ljscip/ObjConshdlr;JJJLjava/lang/String;Ljava/lang/String;JJJJJJJJJJJ)I" + }, + { + "SwigDirector_ObjConshdlr_scip_getvars", "(Ljscip/ObjConshdlr;JJJJIJ)I" + }, + { + "SwigDirector_ObjConshdlr_scip_getnvars", "(Ljscip/ObjConshdlr;JJJJJ)I" + }, + { + "SwigDirector_ObjConshdlr_scip_getdivebdchgs", "(Ljscip/ObjConshdlr;JJJJJJ)I" + }, + { + "SwigDirector_ObjConshdlr_scip_getpermsymgraph", "(Ljscip/ObjConshdlr;JJJJJ)I" + }, + { + "SwigDirector_ObjConshdlr_scip_getsignedpermsymgraph", "(Ljscip/ObjConshdlr;JJJJJ)I" } }; Swig::jclass_SCIPJNIJNI = (jclass) jenv->NewGlobalRef(jcls); diff --git a/src/scipjni_wrap.h b/src/scipjni_wrap.h index f6d542b..c224637 100644 --- a/src/scipjni_wrap.h +++ b/src/scipjni_wrap.h @@ -30,5 +30,73 @@ class SwigDirector_ObjMessagehdlr : public scip::ObjMessagehdlr, public Swig::Di Swig::BoolArray<5> swig_override; }; +class SwigDirector_ObjEventhdlr : public scip::ObjEventhdlr, public Swig::Director { + +public: + void swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global); + SwigDirector_ObjEventhdlr(JNIEnv *jenv, SCIP *scip, char const *name, char const *desc); + virtual ~SwigDirector_ObjEventhdlr(); + virtual SCIP_RETCODE scip_free(SCIP *scip, SCIP_EVENTHDLR *eventhdlr); + virtual SCIP_RETCODE scip_init(SCIP *scip, SCIP_EVENTHDLR *eventhdlr); + virtual SCIP_RETCODE scip_exit(SCIP *scip, SCIP_EVENTHDLR *eventhdlr); + virtual SCIP_RETCODE scip_initsol(SCIP *scip, SCIP_EVENTHDLR *eventhdlr); + virtual SCIP_RETCODE scip_exitsol(SCIP *scip, SCIP_EVENTHDLR *eventhdlr); + virtual SCIP_RETCODE scip_delete(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA **eventdata); + virtual SCIP_RETCODE scip_exec(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_Event *event, SCIP_EVENTDATA *eventdata); +public: + bool swig_overrides(int n) { + return (n < 7 ? swig_override[n] : false); + } +protected: + Swig::BoolArray<7> swig_override; +}; + +class SwigDirector_ObjConshdlr : public scip::ObjConshdlr, public Swig::Director { + +public: + void swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global); + SwigDirector_ObjConshdlr(JNIEnv *jenv, SCIP *scip, char const *name, char const *desc, int sepapriority, int enfopriority, int checkpriority, int sepafreq, int propfreq, int eagerfreq, int scip_maxprerounds, unsigned int delaysepa, unsigned int delayprop, unsigned int needscons, unsigned int proptiming, unsigned int presoltiming); + virtual ~SwigDirector_ObjConshdlr(); + virtual SCIP_RETCODE scip_free(SCIP *scip, SCIP_CONSHDLR *conshdlr); + virtual SCIP_RETCODE scip_init(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss); + virtual SCIP_RETCODE scip_exit(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss); + virtual SCIP_RETCODE scip_initpre(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss); + virtual SCIP_RETCODE scip_exitpre(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss); + virtual SCIP_RETCODE scip_initsol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss); + virtual SCIP_RETCODE scip_exitsol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, unsigned int restart); + virtual SCIP_RETCODE scip_delete(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons, SCIP_CONSDATA **consdata); + virtual SCIP_RETCODE scip_trans(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *sourcecons, SCIP_CONS **targetcons); + virtual SCIP_RETCODE scip_initlp(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, unsigned int *infeasible); + virtual SCIP_RETCODE scip_sepalp(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, int nusefulconss, SCIP_Result *result); + virtual SCIP_RETCODE scip_sepasol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, int nusefulconss, SCIP_SOL *sol, SCIP_Result *result); + virtual SCIP_RETCODE scip_enfolp(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, int nusefulconss, unsigned int solinfeasible, SCIP_Result *result); + virtual SCIP_RETCODE scip_enforelax(SCIP *scip, SCIP_SOL *sol, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, int nusefulconss, unsigned int solinfeasible, SCIP_Result *result); + virtual SCIP_RETCODE scip_enfops(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, int nusefulconss, unsigned int solinfeasible, unsigned int objinfeasible, SCIP_Result *result); + virtual SCIP_RETCODE scip_check(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, SCIP_SOL *sol, unsigned int checkintegrality, unsigned int checklprows, unsigned int printreason, unsigned int completely, SCIP_Result *result); + virtual SCIP_RETCODE scip_prop(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, int nusefulconss, int nmarkedconss, SCIP_PROPTIMING proptiming, SCIP_Result *result); + virtual SCIP_RETCODE scip_presol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss, int nrounds, SCIP_PRESOLTIMING presoltiming, int nnewfixedvars, int nnewaggrvars, int nnewchgvartypes, int nnewchgbds, int nnewholes, int nnewdelconss, int nnewaddconss, int nnewupgdconss, int nnewchgcoefs, int nnewchgsides, int *nfixedvars, int *naggrvars, int *nchgvartypes, int *nchgbds, int *naddholes, int *ndelconss, int *naddconss, int *nupgdconss, int *nchgcoefs, int *nchgsides, SCIP_Result *result); + virtual SCIP_RETCODE scip_resprop(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons, SCIP_VAR *infervar, int inferinfo, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, double relaxedbd, SCIP_Result *result); + virtual SCIP_RETCODE scip_lock(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons, SCIP_LockType locktype, int nlockspos, int nlocksneg); + virtual SCIP_RETCODE scip_active(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons); + virtual SCIP_RETCODE scip_deactive(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons); + virtual SCIP_RETCODE scip_enable(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons); + virtual SCIP_RETCODE scip_disable(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons); + virtual SCIP_RETCODE scip_delvars(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **conss, int nconss); + virtual SCIP_RETCODE scip_print(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons, FILE *file); + virtual SCIP_RETCODE scip_copy(SCIP *scip, SCIP_CONS **cons, char const *name, SCIP *sourcescip, SCIP_CONSHDLR *sourceconshdlr, SCIP_CONS *sourcecons, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, unsigned int initial, unsigned int separate, unsigned int enforce, unsigned int check, unsigned int propagate, unsigned int local, unsigned int modifiable, unsigned int dynamic, unsigned int removable, unsigned int stickingatnode, unsigned int global, unsigned int *valid); + virtual SCIP_RETCODE scip_parse(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS **cons, char const *name, char const *str, unsigned int initial, unsigned int separate, unsigned int enforce, unsigned int check, unsigned int propagate, unsigned int local, unsigned int modifiable, unsigned int dynamic, unsigned int removable, unsigned int stickingatnode, unsigned int *success); + virtual SCIP_RETCODE scip_getvars(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons, SCIP_VAR **vars, int varssize, unsigned int *success); + virtual SCIP_RETCODE scip_getnvars(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons, int *nvars, unsigned int *success); + virtual SCIP_RETCODE scip_getdivebdchgs(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DIVESET *diveset, SCIP_SOL *sol, unsigned int *success, unsigned int *infeasible); + virtual SCIP_RETCODE scip_getpermsymgraph(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons, SYM_GRAPH *graph, unsigned int *success); + virtual SCIP_RETCODE scip_getsignedpermsymgraph(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons, SYM_GRAPH *graph, unsigned int *success); +public: + bool swig_overrides(int n) { + return (n < 33 ? swig_override[n] : false); + } +protected: + Swig::BoolArray<33> swig_override; +}; + #endif