Java Pointer.allocateSizeT方法代码示例

import org.bridj.Pointer; //导入方法依赖的package包/类
public List<Symbol> getSymbols(ShowType type) throws ClingoException {
    List<Symbol> result = null;

    // determine the number of (shown) symbols in the model    
    Pointer<SizeT> size = Pointer.allocateSizeT();
    handleError(LIB.clingo_model_symbols_size(pointer, type.getInt(), size), "Error reading size of symbols of the model");

    if (0 < size.getLong()) {
        // allocate required memory to hold all the symbols
        Pointer<Long> atoms = Pointer.allocateLongs(size.getLong());

        // retrieve the symbols in the model
        handleError(LIB.clingo_model_symbols(pointer, type.getInt(), atoms, size.getLong()), "Error read the model symbols");

        result = Symbol.list(atoms, size.getLong());
    }
    return result;
}
 

import org.bridj.Pointer; //导入方法依赖的package包/类
@Override
public String toString() {
    Pointer<SizeT> size = Pointer.allocateSizeT();
    handleRuntimeError(LIB.clingo_theory_atoms_element_to_string_size(pointer, id, size), "Error reading to string size!");
    Pointer<Byte> string = Pointer.allocateByte();
    handleRuntimeError(LIB.clingo_theory_atoms_element_to_string(pointer, id, string, size.getLong()), "Error reading the theory element string");
    return string.getCString();
}
 

import org.bridj.Pointer; //导入方法依赖的package包/类
public String getValue() throws ClingoException {
    Pointer<SizeT> size = Pointer.allocateSizeT();
    handleError(LIB.clingo_configuration_value_get_size(pointer, key, size), "Error reading the configuration value size!");
    Pointer<Byte> value = Pointer.allocateBytes(size.getInt());
    handleError(LIB.clingo_configuration_value_get(pointer, key, value, size.getInt()), "Error reading the configuration value!");
    return value.getCString();
}
 

import org.bridj.Pointer; //导入方法依赖的package包/类
public List<Signature> getSignatures() throws ClingoException {
    Pointer<SizeT> n = Pointer.allocateSizeT();
    handleError(LIB.clingo_symbolic_atoms_signatures_size(pointer, n), "Error reading the symbolic atoms signatures size!");
    Pointer<Long> signatures = Pointer.allocateLongs(n.getLong());
    handleError(LIB.clingo_symbolic_atoms_signatures(pointer, signatures, n.getLong()), "Error reading the symbolic atoms signatures!");
    return Signature.list(signatures, n.getLong());
}
 

import org.bridj.Pointer; //导入方法依赖的package包/类
public List<Long> getCost() throws ClingoException {
    Pointer<SizeT> n = Pointer.allocateSizeT();
    handleError(LIB.clingo_model_cost_size(pointer, n), "Error reading model cost size!");
    Pointer<Long> ret = Pointer.allocateLongs(n.getLong());
    handleError(LIB.clingo_model_cost(pointer, ret, n.getLong()), "Error reading the model cost!");
    return ret.asList();
}
 

import org.bridj.Pointer; //导入方法依赖的package包/类
@Override
public String toString() {
    Pointer<SizeT> size = Pointer.allocateSizeT();
    handleRuntimeError(LIB.clingo_theory_atoms_atom_to_string_size(pointer, id, size), "Error reading to string size!");
    Pointer<Byte> string = Pointer.allocateByte();
    handleRuntimeError(LIB.clingo_theory_atoms_atom_to_string(pointer, id, string, size.getLong()), "Error reading theory atom string");
    return string.getCString();
}
 

import org.bridj.Pointer; //导入方法依赖的package包/类
@Override
public String toString() {
    Pointer<SizeT> size = Pointer.allocateSizeT();
    handleRuntimeError(LIB.clingo_theory_atoms_term_to_string_size(pointer, id, size), "Error reading to string size!");
    Pointer<Byte> string = Pointer.allocateByte();
    handleRuntimeError(LIB.clingo_theory_atoms_term_to_string(pointer, id, string, size.getLong()), "Error reading the theory term string");
    return string.getCString();
}
 

import org.bridj.Pointer; //导入方法依赖的package包/类
@Override
public String toString() {
    Pointer<SizeT> size = Pointer.allocateSizeT();
    handleRuntimeError(LIB.clingo_symbol_to_string_size(structObject, size), "Error reading the symbol string size!");
    Pointer<Byte> string = Pointer.allocateBytes(size.getLong());
    handleRuntimeError(LIB.clingo_symbol_to_string(structObject, string, size.getLong()), "Error reading the symbol string value!");
    return string.getCString();
}
 

import org.bridj.Pointer; //导入方法依赖的package包/类
public List<TheoryTerm> getTuple() throws ClingoException {
    Pointer<Pointer<Integer>> ret = Pointer.allocatePointer(Integer.class);
    Pointer<SizeT> size = Pointer.allocateSizeT();
    handleError(LIB.clingo_theory_atoms_element_tuple(pointer, id, ret, size), "Error reading theory element tuple!");
    return TheoryTerm.list(pointer, ret.get(), size.getInt());
}
 

import org.bridj.Pointer; //导入方法依赖的package包/类
public List<Integer> getCondition() throws ClingoException {
    Pointer<Pointer<Integer>> ret = Pointer.allocatePointer(Integer.class);
    Pointer<SizeT> size = Pointer.allocateSizeT();
    handleError(LIB.clingo_theory_atoms_element_condition(pointer, id, ret, size), "Error reading the theory elements condition!");
    return Pointer.allocateList(ret.get().getIO(), size.getInt());
}
 

import org.bridj.Pointer; //导入方法依赖的package包/类
@Override
public int size() {
    Pointer<SizeT> ret = Pointer.allocateSizeT();
    handleRuntimeError(LIB.clingo_theory_atoms_size(pointer, ret), "Error reading the theory atoms size!");
    return ret.getInt();
}
 

import org.bridj.Pointer; //导入方法依赖的package包/类
public int size() throws ClingoException {
    Pointer<SizeT> ret = Pointer.allocateSizeT();
    handleError(LIB.clingo_symbolic_atoms_size(pointer, ret), "Error reading the symbolic atoms size!");
    return ret.getInt();
}
 

import org.bridj.Pointer; //导入方法依赖的package包/类
public List<TheoryElement> getElements() throws ClingoException {
    Pointer<Pointer<Integer>> ret = Pointer.allocatePointer(Integer.class);
    Pointer<SizeT> n = Pointer.allocateSizeT();
    handleError(LIB.clingo_theory_atoms_atom_elements(pointer, id, ret, n), "Error reading the theory atom elements!");
    return TheoryElement.list(pointer, ret.get(), n.getInt());
}
 

import org.bridj.Pointer; //导入方法依赖的package包/类
public List<TheoryTerm> getArguments() throws ClingoException {
    Pointer<Pointer<Integer>> ret = Pointer.allocatePointer(Integer.class);
    Pointer<SizeT> n = Pointer.allocateSizeT();
    handleError(LIB.clingo_theory_atoms_term_arguments(pointer, id, ret, n), "Error reading the theory teram arguments!");
    return list(pointer, ret.get(), id);
}
 

import org.bridj.Pointer; //导入方法依赖的package包/类
public List<Symbol> getArguments() throws ClingoException {
    Pointer<Pointer<Long>> args = Pointer.allocatePointer(Long.class);
    Pointer<SizeT> args_size = Pointer.allocateSizeT();
    handleError(LIB.clingo_symbol_arguments(structObject, args, args_size), "Error reading the symbol arguments!");
    return Symbol.list(args.get(), args_size.getInt());
}