/*
   * MIME type is cached so that Locator doesn't need to talk to the server,
   * it can just get the type and buffer and be done
   */
  public CacheReference registerURICache(URI sourceURI, ByteBuffer data, String mimeType) {
    if (Logger.canLog(Logger.DEBUG)) {
      Logger.logMsg(
          Logger.DEBUG,
          "New cache entry: URI " + sourceURI + ", buffer " + data + ", MIME type " + mimeType);
    }

    // ensure the given ByteBuffer is a direct buffer, required for native access
    if (!data.isDirect()) {
      data.rewind();
      ByteBuffer newData = ByteBuffer.allocateDirect(data.capacity());
      newData.put(data);
      data = newData;
    }

    CacheReference ref = new CacheReference(data, mimeType);
    synchronized (uriCache) {
      uriCache.put(sourceURI, new WeakReference(ref));
    }

    // Now register sourceURI with the disposer so we can remove it
    // from uriCache when our cache entry gets collected
    MediaDisposer.addResourceDisposer(ref, sourceURI, cacheDisposer);
    return ref;
  }
  public CacheReference fetchURICache(URI sourceURI) {
    synchronized (uriCache) {
      WeakReference<CacheReference> ref = uriCache.get(sourceURI);
      if (null == ref) {
        return null;
      }

      CacheReference cacheData = ref.get();
      if (null != cacheData) {
        if (Logger.canLog(Logger.DEBUG)) {
          Logger.logMsg(
              Logger.DEBUG,
              "Fetched cache entry: URI "
                  + sourceURI
                  + ", buffer "
                  + cacheData.getBuffer()
                  + ", MIME type "
                  + cacheData.getMIMEType());
        }

        return cacheData;
      }
    }
    return null;
  }
示例#3
0
  /**
   * The SQLException instance contains the following information that can help determine the cause
   * of the error:
   *
   * <p>A description of the error. Retrieve the String object that contains this description by
   * calling the method SQLException.getMessage.
   *
   * <p>A SQLState code. These codes and their respective meanings have been standardized by
   * ISO/ANSI and Open Group (X/Open), although some codes have been reserved for database vendors
   * to define for themselves. This String object consists of five alphanumeric characters. Retrieve
   * this code by calling the method SQLException.getSQLState.
   *
   * <p>An error code. This is an integer value identifying the error that caused the SQLException
   * instance to be thrown. Its value and meaning are implementation-specific and might be the
   * actual error code returned by the underlying data source. Retrieve the error by calling the
   * method SQLException.getErrorCode.
   *
   * <p>A cause. A SQLException instance might have a causal relationship, which consists of one or
   * more Throwable objects that caused the SQLException instance to be thrown. To navigate this
   * chain of causes, recursively call the method SQLException.getCause until a null value is
   * returned.
   *
   * <p>A reference to any chained exceptions. If more than one error occurs, the exceptions are
   * referenced through this chain. Retrieve these exceptions by calling the method
   * SQLException.getNextException on the exception that was thrown.
   *
   * <p>Retrieving Exceptions
   *
   * <p>The following method, JDBCTutorialUtilities.printSQLException outputs the SQLState, error
   * code, error description, and cause (if there is one) contained in the SQLException as well as
   * any other exception chained to it:
   *
   * @param ex The SQLException thrown by the function in question.
   */
  public static void printSQLException(SQLException ex) {

    for (Throwable e : ex) {
      if (e instanceof SQLException && !ignoreSQLException(((SQLException) e).getSQLState())) {

        e.printStackTrace(System.err);
        Logger.logMsg(1, "SQLState: " + ((SQLException) e).getSQLState());

        Logger.logMsg(1, "Error Code: " + ((SQLException) e).getErrorCode());

        Logger.logMsg(1, "Message: " + e.getMessage());

        Throwable t = ex.getCause();
        while (t != null) {
          Logger.logMsg(1, "Cause: " + t);
          t = t.getCause();
        }
      }
    }
  }