Java PrologException.typeError方法代码示例

import gnu.prolog.vm.PrologException; //导入方法依赖的package包/类
/**
 * Get a graph from a term representing a graph
 * @param term      A term representing a graph
 * @return          A graph
 */
public static final Graph getGraph(Term term) throws PrologException {
    if (term instanceof JavaObjectTerm) {
        JavaObjectTerm jot = (JavaObjectTerm) term;
        if (jot.value instanceof GraphState) {
            return ((GraphState) jot.value).getGraph();
        }
        if (jot.value instanceof Graph) {
            return (Graph) jot.value;
        }
        PrologException.domainError(GraphPrologCode.GRAPH_ATOM, term);
    } else {
        PrologException.typeError(GraphPrologCode.GRAPH_ATOM, term);
    }
    return null;
}
 

import gnu.prolog.vm.PrologException; //导入方法依赖的package包/类
/**
 * Get a host graph from a term representing a host graph
 * @param term      A term representing a host graph
 * @return          A host graph
 */
public static final HostGraph getHostGraph(Term term)
    throws PrologException {
    if (term instanceof JavaObjectTerm) {
        JavaObjectTerm jot = (JavaObjectTerm) term;
        if (jot.value instanceof GraphState) {
            return ((GraphState) jot.value).getGraph();
        }
        if (jot.value instanceof HostGraph) {
            return (HostGraph) jot.value;
        }
        PrologException.domainError(GraphPrologCode.GRAPH_ATOM, term);
    } else {
        PrologException.typeError(GraphPrologCode.GRAPH_ATOM, term);
    }
    return null;
}
 

import gnu.prolog.vm.PrologException; //导入方法依赖的package包/类
/**
 * Gets a valuenode from a term
 * @param term      A term representing a valuenode
 * @return          A valuenode
 */
public static final ValueNode getValueNode(Term term)
    throws PrologException {
    if (term instanceof JavaObjectTerm) {
        JavaObjectTerm jot = (JavaObjectTerm) term;
        if (!(jot.value instanceof ValueNode)) {
            PrologException.domainError(VALUENODE_ATOM, term);
        }
        return (ValueNode) jot.value;
    } else {
        PrologException.typeError(VALUENODE_ATOM, term);
    }
    return null;
}
 

import gnu.prolog.vm.PrologException; //导入方法依赖的package包/类
/**
 * Get a rule event from a term representing a rule event
 * @param term      A term representing a rule event
 * @return          A rule event
 */
public static final RuleEvent getRuleEvent(Term term)
    throws PrologException {
    if (term instanceof JavaObjectTerm) {
        JavaObjectTerm jot = (JavaObjectTerm) term;
        if (!(jot.value instanceof RuleEvent)) {
            PrologException.domainError(RULEEVENT_ATOM, term);
        }
        return (RuleEvent) jot.value;
    } else {
        PrologException.typeError(RULEEVENT_ATOM, term);
    }
    return null;

}
 

import gnu.prolog.vm.PrologException; //导入方法依赖的package包/类
/**
 * Get a rule from a term representing a rule
 * @param term      A term representing a rule
 * @return          A rule
 */
public static final Rule getRule(Term term) throws PrologException {
    if (term instanceof JavaObjectTerm) {
        JavaObjectTerm jot = (JavaObjectTerm) term;
        if (!(jot.value instanceof Rule)) {
            PrologException.domainError(RULE_ATOM, term);
        }
        return (Rule) jot.value;
    } else {
        PrologException.typeError(RULE_ATOM, term);
    }
    return null;

}
 

import gnu.prolog.vm.PrologException; //导入方法依赖的package包/类
/**
 * Get a graph state from a term representing a graph state
 * @param term      A term representing a graph state
 * @return          A graph state
 */
public static final GraphState getGraphState(Term term)
    throws PrologException {
    if (term instanceof JavaObjectTerm) {
        JavaObjectTerm jot = (JavaObjectTerm) term;
        if (!(jot.value instanceof GraphState)) {
            PrologException.domainError(LtsPrologCode.GRAPHSTATE_ATOM, term);
        }
        return (GraphState) jot.value;
    } else {
        PrologException.typeError(LtsPrologCode.GRAPHSTATE_ATOM, term);
    }
    return null;
}
 

import gnu.prolog.vm.PrologException; //导入方法依赖的package包/类
/**
 * Get a GTS from a term representing a GTS
 * @param term      A term representing a GTS
 * @return          A GTS
 */
public static final GTS getLTS(Term term) throws PrologException {
    if (term instanceof JavaObjectTerm) {
        JavaObjectTerm jot = (JavaObjectTerm) term;
        if (!(jot.value instanceof GTS)) {
            PrologException.domainError(LtsPrologCode.GTS_ATOM, term);
        }
        return (GTS) jot.value;
    } else {
        PrologException.typeError(LtsPrologCode.GTS_ATOM, term);
    }
    return null;
}
 

import gnu.prolog.vm.PrologException; //导入方法依赖的package包/类
/**
 * Get a graph transition from a term representing a graph transition
 * @param term      A term representing a graph transition
 * @return          A graph transition
 */
public static final RuleTransition getTransition(Term term)
    throws PrologException {
    if (term instanceof JavaObjectTerm) {
        JavaObjectTerm jot = (JavaObjectTerm) term;
        if (!(jot.value instanceof RuleTransition)) {
            PrologException.domainError(LtsPrologCode.TRANSITION_ATOM, term);
        }
        return (RuleTransition) jot.value;
    } else {
        PrologException.typeError(LtsPrologCode.TRANSITION_ATOM, term);
    }
    return null;
}
 

import gnu.prolog.vm.PrologException; //导入方法依赖的package包/类
/**
 * Get an edge from a term representing an edge
 * @param term      A term representing an edge
 * @return          An edge
 */
public static final Edge getEdge(Term term) throws PrologException {
    if (term instanceof JavaObjectTerm) {
        JavaObjectTerm jot = (JavaObjectTerm) term;
        if (!(jot.value instanceof Edge)) {
            PrologException.domainError(GraphPrologCode.EDGE_ATOM, term);
        }
        return (Edge) jot.value;
    } else {
        PrologException.typeError(GraphPrologCode.EDGE_ATOM, term);
    }
    return null;
}
 

import gnu.prolog.vm.PrologException; //导入方法依赖的package包/类
/**
 * Get a node from a term representing a node
 * @param term      A term representing a node
 * @return          A node
 */
public static final Node getNode(Term term) throws PrologException {
    if (term instanceof JavaObjectTerm) {
        JavaObjectTerm jot = (JavaObjectTerm) term;
        if (!(jot.value instanceof Node)) {
            PrologException.domainError(GraphPrologCode.NODE_ATOM, term);
        }
        return (Node) jot.value;
    } else {
        PrologException.typeError(GraphPrologCode.NODE_ATOM, term);
    }
    return null;
}
 

import gnu.prolog.vm.PrologException; //导入方法依赖的package包/类
@Override
public int execute(Interpreter interpreter, boolean backtrackMode, Term[] args)
    throws PrologException {
    try {
        Graph graph = (Graph) ((JavaObjectTerm) args[0]).value;
        GraphPreviewDialog.showGraph(graph);
        return SUCCESS_LAST;
    } catch (ClassCastException e) {
        PrologException.typeError(GRAPH_ATOM, args[0]);
        return FAIL;
    }
}