Java Pointer.allocateInt方法代码示例

import org.bridj.Pointer; //导入方法依赖的package包/类
private static boolean solve(Pointer<Pointer<clingo_control>> ctrl) {
    Pointer<Integer> result = Pointer.allocateInt();
    Pointer<Pointer<clingo_solve_handle>> handle = Pointer.allocatePointer(clingo_solve_handle.class);
    Pointer<Pointer<clingo_model>> model = Pointer.allocatePointer(clingo_model.class);

    // get a solve handle        
    if (!LIB.clingo_control_solve(ctrl.get(), (int) clingo_solve_mode.clingo_solve_mode_yield.value, null, 0, null, null, handle)) {
        error(ctrl, "Error execute control solve");
    }

    // loop over all models
    boolean run = true;
    while (run) {

        if (!LIB.clingo_solve_handle_resume(handle.get())) {
            error(ctrl, "Error solve handle resume");
        }
        if (!LIB.clingo_solve_handle_model(handle.get(), model)) {
            error(ctrl, "Error solve handle model");
        }

        // print the model
        if (model.get() != null) {
            printModel(ctrl, model);
        } else {
            // stop if there are no more models
            run = false;
        }
    }

    // close the solve handle
    if (!LIB.clingo_solve_handle_get(handle.get(), result)) {
        error(ctrl, "Error solve handle get");
    }

    return LIB.clingo_solve_handle_close(handle.get());
}
 

import org.bridj.Pointer; //导入方法依赖的package包/类
public String getVersion() {
    Pointer<Integer> major = Pointer.allocateInt();
    Pointer<Integer> minor = Pointer.allocateInt();
    Pointer<Integer> revision = Pointer.allocateInt();
    LIB.clingo_version(major, minor, revision);
    return "" + major.getInt() + "." + minor.getInt() + "." + revision.getInt();
}
 

import org.bridj.Pointer; //导入方法依赖的package包/类
public Configuration getConfiguration() throws ClingoException {
    Pointer<Pointer<clingo_configuration>> config = Pointer.allocatePointer(clingo_configuration.class);
    handleError(LIB.clingo_control_configuration(pointer, config), "Error reading the configuration!");
    Pointer<Integer> key = Pointer.allocateInt();
    handleError(LIB.clingo_configuration_root(config.get(), key), "Error reading the configuration root key!");
    return new Configuration(config.get(), key.getInt());
}
 

import org.bridj.Pointer; //导入方法依赖的package包/类
public int getConditionId() throws ClingoException {
    Pointer<Integer> ret = Pointer.allocateInt();
    handleError(LIB.clingo_theory_atoms_element_condition_id(pointer, id, ret), "Error reading the theory element condition id!");
    return ret.get();
}
 

import org.bridj.Pointer; //导入方法依赖的package包/类
public int getNumber() throws ClingoException {
    Pointer<Integer> number = Pointer.allocateInt();
    handleError(LIB.clingo_symbol_number(structObject, number), "Error reading the symbol number!");
    return number.get();
}
 

import org.bridj.Pointer; //导入方法依赖的package包/类
public int getType() throws ClingoException {
    Pointer<Integer> tmp = Pointer.allocateInt();
    handleError(LIB.clingo_configuration_type(pointer, key, tmp), "Error reading the configuration type!");
    return tmp.getInt();
}
 

import org.bridj.Pointer; //导入方法依赖的package包/类
public int addAtom() throws ClingoException {
    Pointer<Integer> ret = Pointer.allocateInt();
    handleError(LIB.clingo_backend_add_atom(pointer, ret), "Error add the atom to the backend!");
    return ret.getInt();
}
 

import org.bridj.Pointer; //导入方法依赖的package包/类
public int getLevel(int lit) throws ClingoException {
    Pointer<Integer> ret = Pointer.allocateInt();
    handleError(LIB.clingo_assignment_level(pointer, lit, ret), "Error reading the assignment level!");
    return ret.getInt();
}
 

import org.bridj.Pointer; //导入方法依赖的package包/类
public int getDecision(int level) throws ClingoException {
    Pointer<Integer> ret = Pointer.allocateInt();
    handleError(LIB.clingo_assignment_decision(pointer, level, ret), "Error reading the assignment decision!");
    return ret.getInt();
}
 

import org.bridj.Pointer; //导入方法依赖的package包/类
public StatisticsType getType() throws ClingoException {
    Pointer<Integer> value = Pointer.allocateInt();
    handleError(LIB.clingo_statistics_type(pointer, key, value), "Error reading the statistric type!");
    return EnumValue.valueOfInt(StatisticsType.class, value.getInt());
}
 

import org.bridj.Pointer; //导入方法依赖的package包/类
@Override
public Configuration get(int index) {
    Pointer<Integer> subkey = Pointer.allocateInt();
    handleRuntimeError(LIB.clingo_configuration_array_at(pointer, key, index, subkey), "Error reading the configuration item in array at " + index + " position!");
    return new Configuration(pointer, subkey.getInt());
}
 

import org.bridj.Pointer; //导入方法依赖的package包/类
public ModelType getType() throws ClingoException {
    Pointer<Integer> type = Pointer.allocateInt();
    handleError(LIB.clingo_model_type(pointer, type), "Error reading the model type");
    return EnumValue.valueOfInt(ModelType.class, type.get());
}
 

import org.bridj.Pointer; //导入方法依赖的package包/类
public int getThreadId() throws ClingoException {
    Pointer<Integer> ret = Pointer.allocateInt();
    handleError(LIB.clingo_model_thread_id(pointer, ret), "Error reading the model thread id!");
    return ret.get();
}
 

import org.bridj.Pointer; //导入方法依赖的package包/类
public int addLiteral() throws ClingoException {
    Pointer<Integer> ret = Pointer.allocateInt();
    handleError(LIB.clingo_propagate_control_add_literal(pointer, ret), "Error add the literal to the propagate control!");
    return ret.getInt();
}
 

import org.bridj.Pointer; //导入方法依赖的package包/类
public int getLiteral() throws ClingoException {
    Pointer<Integer> literal = Pointer.allocateInt();
    handleError(LIB.clingo_symbolic_atoms_literal(pointer, iterator, literal), "Error reading the atoms litral!");
    return literal.get();
}