private ConverseException(final Object command, CycAccess cyc, final Object[] response) {
   super(
       response[1].toString()
           + "\nrequest "
           + (cyc.hasStaticCycServer()
               ? "to " + (cyc.getHostName() + ":" + cyc.getBasePort())
               : "")
           + " : "
           + makeRequestString(command));
   if (response[1] instanceof CycApiException) {
     this.initCause((CycApiException) response[1]);
   }
 }
 public CycServerInfoImpl(CycAccess cyc) {
   this.cyc = cyc;
   if ((cyc != null) && !cyc.isClosed()) {
     this.server = cyc.getCycServer();
   } else {
     server = null;
   }
   try {
     reloadCache();
   } catch (SessionCommunicationException ex) {
     throw new SessionApiRuntimeException(ex);
   }
 }
Exemple #3
0
  @Test
  public void testFactCycObject() throws Exception {
    System.out.println("Running testFactCycObject");
    CycAccess cyc = CycAccessManager.getCurrentAccess();
    FormulaSentence cfs =
        CycFormulaSentence.makeCycSentence(cyc, "(isa Plane-APITest CommercialAircraft)");
    CycConstant cc = cyc.getLookupTool().find("SomeAirlineEquipmentMt");
    CycAssertion ca = new CycAssertionImpl(cfs, cc);
    System.out.println("Assertion OC API: " + ca);

    FactImpl f = new FactImpl(ca);
    assertEquals(ca, f.getCore());
  }
 /**
  * Test to see if <code>compactExternalId</code> is a compact HL-ID, and return the relevant
  * object iff <code>compactExternalId</code> is the canonical id for the object. This is intended
  * to be used in cases where it's not known whether compactExternalId is in fact a valid compact
  * HL-ID, as it performs extra checks to make sure that the string is in fact the HL-ID for the
  * returned object.
  *
  * @param compactExternalId
  * @param access
  * @return the object uniquely identified by compactExternalId
  * @see #fromCompactExternalId(java.lang.String, com.cyc.base.CycAccess)
  * @throws IOException
  */
 public static Object fromPossibleCompactExternalId(String compactExternalId, CycAccess access)
     throws CycConnectionException {
   if ((compactExternalId == null) || ("".equals(compactExternalId))) {
     throw new IllegalArgumentException(compactExternalId + "is not a valid compact external id.");
   }
   // @todo support CompactHLIDConverter.converter() once we can simply identify
   // if a compact external id is a String or Number
   Object result = compactExternalIdToCycObjectCache.get(compactExternalId);
   if (result != null) {
     return result;
   }
   try {
     if (CompactHLIDConverter.converter().isNumberCompactHLId(compactExternalId)) {
       Number num = (Number) CompactHLIDConverter.converter().fromCompactHLId(compactExternalId);
       result = CycObjectFactory.makeCycNumber(num);
     } else {
       result =
           access
               .converse()
               .converseList(
                   "(multiple-value-list (maybe-find-object-by-compact-hl-external-id-string "
                       + DefaultCycObject.stringApiValue(compactExternalId)
                       + "))");
       if (((CycArrayList) result).second() == CycObjectFactory.nil) {
         return null;
       }
     }
   } catch (IOException ioe) {
     throw new CycConnectionException(ioe);
   }
   compactExternalIdToCycObjectCache.put(compactExternalId, ((CycArrayList) result).first());
   return ((CycArrayList) result).first();
 }
 /**
  * Return the sources to which this answer is attributed.
  *
  * @return the sources to which this answer is attributed.
  */
 @Override
 public Collection<InformationSource> getSources(
     InformationSource.CitationGenerator citationGenerator) throws CycConnectionException {
   final String command =
       SubLAPIHelper.makeSubLStmt(
           "inference-answer-sources-from-signature", getId().cycListApiValue());
   final Set<InformationSource> sources = new HashSet<InformationSource>();
   final CycAccess cycAccess = getCycAccess();
   for (final Object sourceObj : cycAccess.converse().converseList(command)) {
     if (sourceObj instanceof DenotationalTerm) {
       sources.add(
           new InformationSourceImpl((DenotationalTerm) sourceObj, citationGenerator, cycAccess));
     }
   }
   return sources;
 }
 public static String toCompactExternalId(Object cycObject, CycAccess access)
     throws CycConnectionException {
   if ((cycObject == null) || (!DefaultCycObject.isCycLObject(cycObject))) {
     throw new IllegalArgumentException(cycObject + "is not a valid CycL object.");
   }
   try {
     if (cycObject instanceof Number) {
       return CompactHLIDConverter.converter().toCompactHLId((Number) cycObject);
     }
     if (cycObject instanceof CycNumberImpl) {
       return CompactHLIDConverter.converter()
           .toCompactHLId(((CycNumberImpl) cycObject).getNumber());
     }
     if (cycObject instanceof String) {
       return CompactHLIDConverter.converter().toCompactHLId((String) cycObject);
     }
   } catch (IOException ioe) {
     throw new CycConnectionException(ioe);
   }
   Object result = cycObjectToCompactExternalIdCache.get(cycObject);
   if (result != null) {
     return (String) result;
   }
   result =
       access
           .converse()
           .converseObject(
               "(compact-hl-external-id-string "
                   + DefaultCycObject.stringApiValue(cycObject)
                   + ")");
   if (!(result instanceof String)) {
     throw new BaseClientRuntimeException("Got invalid result: " + result);
   }
   cycObjectToCompactExternalIdCache.put(cycObject, (String) result);
   return (String) result;
 }
 /**
  * Returns whether the given Object represents a Cyc Collection.
  *
  * @return whether the given Object represents a Cyc Collection.
  */
 public static boolean isCollection(Object term, CycAccess cycAccess)
     throws CycConnectionException {
   return cycAccess.getInspectorTool().isCollection(term);
 }