Java KbTerm类代码示例

import com.cyc.kb.KbTerm; //导入依赖的package包/类
@Override
protected abstract KbTerm wrapped();
 

import com.cyc.kb.KbTerm; //导入依赖的package包/类
@Override
public KbTerm rename(String name) throws InvalidNameException {
  return wrapped().rename(name);
}
 

import com.cyc.kb.KbTerm; //导入依赖的package包/类
@Override
public KbTerm addQuotedIsa(KbCollection collection, Context context)
        throws KbTypeException, CreateException {
  return wrapped().addQuotedIsa(collection, context);
}
 

import com.cyc.kb.KbTerm; //导入依赖的package包/类
@Override
public KbTerm instantiates(KbCollection collection, Context context)
        throws KbTypeException, CreateException {
  return wrapped().instantiates(collection, context);
}
 

import com.cyc.kb.KbTerm; //导入依赖的package包/类
/**
 * Perform some simple term lookup and creation. Most of the methods in the KB API and the Query 
 * API will accept both Strings and KB objects for their arguments.  But it's good practice to
 * create the KB object versions, and use them.  In this file, we'll alternate back and forth 
 * between using KB object and using Strings for these arguments.  Here's how you retrieve the KB
 * objects.
 * 
 * @throws KbTypeException
 * @throws CreateException 
 * @throws DeleteException 
 */
protected void basicTermLookup()
        throws KbTypeException, CreateException, DeleteException {
  System.out.println();
  
  /* 
   KbObjects are requested from factories, and there is KB factory for each KbObject type.
   Here, we find or create an Individual term in the KB to represent the actor Jack Nicholson.
  */
  KbIndividual nicholsonIndividual = KbIndividual.findOrCreate("JackNicholson");
  System.out.println("Jack Nicholson as an individual: "
          + nicholsonIndividual);
  
  /* 
   And here, we request JackNicholson as a KbTerm, which is a super-type of KbIndividual. Note 
   that we're now using the get method, which should only be used if you're sure the term is in 
   the KB. This code shows how to test whether a term is in the KB (in a form that can be cast to 
   the desired type) before actually retrieving it. In most real-world cases, you won't run this
   test before every call to get. 
   */
  KbTerm nicholsonTerm = null;
  if (KbTerm.existsAsType("JackNicholson")) {
    nicholsonTerm = KbTerm.get("JackNicholson");
  }
  System.out.println("Jack Nicholson as a term: " + nicholsonTerm);
  
  /*
   We can also confirm that Jack Nicholson isn't, say, a KbCollection.
   */
  System.out.println("Is Jack Nicholson a collection? "
          + KbCollection.existsAsType("JackNicholson"));
  
  /*
   The KbObject factories are intelligent enough to return an instance of the most specific type.
   Because JackNicholson is an Individual, and because KbIndividual is a subclass of KbTerm,
   either factory will return an instance of KbIndividual. And, because of caching, they will 
   return the *same* instance of KbIndividual:
   */
  System.out.println("Are the KbTerm and KbIndividual for #$JackNicholson the exact same object? "
          + (nicholsonIndividual == nicholsonTerm));
  
  /*
   Now, let's check whether the movie _King of Marvin Gardens_ exists in Cyc's KB. Here is some
   slightly different syntax for checking whether it can be expressed as a KbIndividual:
  */
  System.out.println("Does Cyc already know that _King of Marvin Gardens_ is an individual? "
          + KbIndividual.existsAsType("TheKingOfMarvinGardens-TheMovie"));
  
  /*
   And here's a way to check whether the term exists at all:
   */
  System.out.println("Does _King of Marvin Gardens_ exist in Cyc's KB at all? "
          + Cyc.existsInKb("TheKingOfMarvinGardens-TheMovie"));
  
  /*
   For sake of the example, let's ensure that _King of Marvin Gardens_ does NOT exist in Cyc's KB.
   Of course, it needs to exist in order for us to delete it, and we could check 
   KbFactory#existsInKb() (like we just did above) to determine whether it exists. But for sake of
   the example let's assume that it's in the KB, and add some code for handling the case where it 
   isn't:
   */
  try {
    KbTerm.get("TheKingOfMarvinGardens-TheMovie").delete();
    System.out.println("TheKingOfMarvinGardens-TheMovie: deleted!");
  } catch (KbObjectNotFoundException e) {
    System.out.println("Apparently TheKingOfMarvinGardens-TheMovie wasn't in the KB,"
            + " but we'll just carry on: " + " (" + e.getMessage() + ")");
  }
}
 

import com.cyc.kb.KbTerm; //导入依赖的package包/类
/**
 * Get the attributed sources used in inferring this answer. Generally, results will include SKSI
 * sources, or terms used in meta-assertions using sourceOfTerm-NonTrivial or its specializations.
 * Note that this method works by introspecting on the inference object, and will not work if the
 * inference has already been destroyed when this is called. The canonical way of ensuring that
 * the inference is not destroyed immediately is to call 
 * {@link com.cyc.query.Query#retainInference()}, though there are other ways of ensuring the 
 * inference is not immediately destroyed, such as 
 * {@link com.cyc.query.Query#setBrowsable(boolean)} and 
 * {@link com.cyc.query.Query#setContinuable(boolean)}.
 *
 * @return A set of KbTerms that are the attributed sources for this answer.
 */
Set<KbTerm> getSources();
 

import com.cyc.kb.KbTerm; //导入依赖的package包/类
/**
 * Get the <code>KbTerm</code> with the name <code>nameOrId</code>. Throws exceptions if there is
 * no KB term by that name, or if it is not already an instance of #$Thing.
 *
 * @param nameOrId the string representation or the HLID of the term
 *
 * @return a new KbTerm
 *
 * @throws KbTypeException
 * @throws CreateException
 */
KbTerm get(String nameOrId) throws KbTypeException, CreateException;
 

import com.cyc.kb.KbTerm; //导入依赖的package包/类
/**
 * Find or create a <code>KbTerm</code> object named <code>nameOrId</code>. If no object exists in
 * the KB with the name <code>nameOrId</code>, one will be created, and it will be asserted to be
 * an instance of <code>#$Thing</code>. If there is already an object in the KB called
 * <code>nameOrId</code>, it will be returned.
 *
 * @param nameOrId the string representation or the HLID of the term
 *
 * @return a new KbTerm
 *
 * @throws KbTypeException
 * @throws CreateException
 */
KbTerm findOrCreate(String nameOrId) throws CreateException, KbTypeException;