/**
   * Test concurrent access: First build a clone iterator in a separate thread that hangs
   * momentarily during its construction; then modify the shared collection in this thread. This
   * would cause a ConcurrentModificationException in the other thread if the clone iterator were
   * not synchronized on the original collection.
   */
  public void testConcurrentAccess() throws Exception {
    SlowCollection slow = new SlowCollection();
    this.populateCollection(slow);
    // using the unsynchronized collection will cause the test to fail
    //		this.originalCollection = slow;
    this.originalCollection = Collections.synchronizedCollection(slow);

    this.concurrentProblem = false;
    this.concurrentCollection = new ArrayList();
    Thread thread = new Thread(this.buildRunnable());
    thread.start();
    while (!slow.hasStartedClone()) {
      // wait for the other thread to start the clone...
      Thread.yield();
    }
    // ...then sneak in an extra element
    this.originalCollection.add("seventeen");
    while (thread.isAlive()) {
      // wait for the other thread to finish
      Thread.yield();
    }
    assertFalse(this.concurrentProblem);
    Collection expected = new ArrayList();
    this.populateCollection(expected);
    assertEquals(expected, this.concurrentCollection);
  }
Esempio n. 2
0
  /**
   * Adds the value to the collection specified by the key. If there is not a collection for the
   * given key, a new collection is created and added to the hash.
   *
   * @param key The key whose collection we will add value to.
   * @param value The value to be added.
   * @return the collection containing value and all other items associated with the key.
   */
  @SuppressWarnings("unchecked")
  public Collection<V> put(K key, V value) {
    Pair<Collection<V>, O> objectPair = map.get(key);
    if (objectPair == null) {
      try {
        Collection<V> items;
        if (isSynchronized) {
          items = Collections.synchronizedCollection(collectionType.newInstance());
        } else {
          items = collectionType.newInstance();
        }

        objectPair = new Pair(items, plusProvider.newObject());
        map.put(key, objectPair);
      } catch (InstantiationException ex) {
        ex.printStackTrace();
        return null;
      } catch (IllegalAccessException ex) {
        ex.printStackTrace();
        return null;
      }
    }
    objectPair.getFirst().add(value);
    return objectPair.getFirst();
  }
Esempio n. 3
0
 public RunThread(Collection<Operation> ops, User u) {
   super("CacheValidatorThread");
   setDaemon(true);
   operations = ops;
   user = u;
   errs = Collections.synchronizedCollection(new RingBuffer<String>(10));
 }
Esempio n. 4
0
 public synchronized void start() throws ResourceManagerSystemException {
   logger.info("Starting ResourceManager");
   operationMode = OPERATION_MODE_STARTING;
   globalTransactions = Collections.synchronizedCollection(new ArrayList());
   // TODO: recover and sync
   doStart();
   recover();
   // sync();
   operationMode = OPERATION_MODE_STARTED;
   if (dirty) {
     logger.warn(
         "Started ResourceManager, but in dirty mode only (Recovery of pending transactions failed)");
   } else {
     logger.info("Started ResourceManager");
   }
 }
Esempio n. 5
0
    public static class DefaultEventSource implements EventSource {
      private final Collection<Body> mBodies =
          Collections.synchronizedCollection(new ArrayList<Body>());

      @Override
      public final void connect(Body body) {
        mBodies.add(body);
      }

      public final void write(final String data) {
        final Iterator<Body> i = mBodies.iterator();
        while (i.hasNext()) {
          final Body body = i.next();
          if (body.isStopped()) {
            i.remove();
          } else {
            body.writeEventData(data);
          }
        }
      }

      public final void end(final String data) {
        final Iterator<Body> i = mBodies.iterator();
        while (i.hasNext()) {
          final Body body = i.next();
          if (body.isStopped()) {
            i.remove();
          } else {
            body.writeEventData(data);
            body.stop();
            i.remove();
          }
        }
      }

      public final void end() {
        final Iterator<Body> i = mBodies.iterator();
        while (i.hasNext()) {
          final Body body = i.next();
          if (!body.isStopped()) {
            body.stop();
          }
          i.remove();
        }
      }
    }
Esempio n. 6
0
 public Pluginer(
     File source,
     File process,
     File destination,
     Downloader coworker,
     ImageProcessingLogger log,
     ArrayList<Plugin> plugins) {
   super(log);
   this.source = source;
   this.process = process;
   this.destination = destination;
   this.coworker = coworker;
   this.plugins = plugins;
   this.filePlugin = new ArrayList<String>();
   this.filePlugin.addAll(Arrays.asList(destination.list()));
   Collections.synchronizedCollection(filePlugin);
 }
  @RaceTest(
      expectRace = false,
      description = "Test instrumentation of Collections$SynchronizedX classes")
  public void synchronizedCollections() {
    final Collection<Integer> c = Collections.synchronizedCollection(new ArrayList<Integer>());
    new ThreadRunner(2) {

      @Override
      public void thread1() {
        c.add(1);
      }

      @Override
      public void thread2() {
        c.contains(1);
      }
    };
  }
  @RaceTest(
      expectRace = true,
      description = "iterate over synchronized collection without manually synchronize on it")
  public void iterateSyncCollectionWrong() {
    ArrayList<Integer> a = new ArrayList<>();
    a.add(0);
    a.add(1);
    final Collection<Integer> c = Collections.synchronizedCollection(a);

    new ThreadRunner(2) {

      @Override
      public void thread1() {
        c.iterator().hasNext(); // explicit iterator
        for (Integer i : c) {}
        ; // implicit iterator
      }

      @Override
      public void thread2() {
        c.add(2);
      }
    };
  }
 /**
  * Returns a {@link Collection} view of the values contained in this map. The collection is backed
  * by the map, so changes to the map are reflected in the collection, and vice-versa. If the map
  * is modified while an iteration over the collection is in progress (except through the
  * iterator's own {@code remove} operation), the results of the iteration are undefined. The
  * collection supports element removal, which removes the corresponding mapping from the map, via
  * the {@code Iterator.remove}, {@code Collection.remove}, {@code removeAll}, {@code retainAll}
  * and {@code clear} operations. It does not support the {@code add} or {@code addAll} operations.
  *
  * @since 1.2
  */
 public Collection<V> values() {
   if (values == null) values = Collections.synchronizedCollection(new ValueCollection(), this);
   return values;
 }
Esempio n. 10
0
/**
 * A utility class that provides easy access to Structure objects. If you are running a script that
 * is frequently re-using the same PDB structures, the AtomCache keeps an in-memory cache of the
 * files for quicker access. The cache is a soft-cache, this means it won't cause out of memory
 * exceptions, but garbage collects the data if the Java virtual machine needs to free up space. The
 * AtomCache is thread-safe.
 *
 * @author Andreas Prlic
 * @author Spencer Bliven
 * @author Peter Rose
 * @since 3.0
 */
public class AtomCache {

  private static final Logger logger = LoggerFactory.getLogger(AtomCache.class);

  public static final String BIOL_ASSEMBLY_IDENTIFIER = "BIO:";
  public static final String CHAIN_NR_SYMBOL = ":";
  public static final String CHAIN_SPLIT_SYMBOL = ".";

  public static final String PDP_DOMAIN_IDENTIFIER = "PDP:";

  public static final String UNDERSCORE = "_";

  private static final String FILE_SEPARATOR = System.getProperty("file.separator");

  protected FileParsingParameters params;
  protected PDPProvider pdpprovider;

  private FetchBehavior fetchBehavior;
  private ObsoleteBehavior obsoleteBehavior;

  private String cachePath;

  // make sure IDs are loaded uniquely
  private Collection<String> currentlyLoading =
      Collections.synchronizedCollection(new TreeSet<String>());

  private String path;

  private boolean useMmCif;

  /**
   * Default AtomCache constructor.
   *
   * <p>Usually stores files in a temp directory, but this can be overriden by setting the PDB_DIR
   * variable at runtime.
   *
   * @see UserConfiguration#UserConfiguration()
   */
  public AtomCache() {
    this(new UserConfiguration());
  }

  /**
   * Creates an instance of an AtomCache that is pointed to the a particular path in the file
   * system. It will use the same value for pdbFilePath and cachePath.
   *
   * @param pdbFilePath a directory in the file system to use as a location to cache files.
   */
  public AtomCache(String pdbFilePath) {
    this(pdbFilePath, pdbFilePath);
  }

  /**
   * Creates an instance of an AtomCache that is pointed to the a particular path in the file
   * system.
   *
   * @param pdbFilePath a directory in the file system to use as a location to cache files.
   * @param cachePath
   */
  public AtomCache(String pdbFilePath, String cachePath) {

    logger.debug(
        "Initialising AtomCache with pdbFilePath={}, cachePath={}", pdbFilePath, cachePath);

    if (!pdbFilePath.endsWith(FILE_SEPARATOR)) {
      pdbFilePath += FILE_SEPARATOR;
    }

    // we are caching the binary files that contain the PDBs gzipped
    // that is the most memory efficient way of caching...
    // set the input stream provider to caching mode
    System.setProperty(InputStreamProvider.CACHE_PROPERTY, "true");

    setPath(pdbFilePath);

    this.cachePath = cachePath;

    fetchBehavior = FetchBehavior.DEFAULT;
    obsoleteBehavior = ObsoleteBehavior.DEFAULT;

    currentlyLoading.clear();
    params = new FileParsingParameters();

    setUseMmCif(true);
  }

  /**
   * @param isSplit Ignored
   * @deprecated isSplit parameter is ignored (4.0.0)
   */
  @Deprecated
  public AtomCache(String pdbFilePath, boolean isSplit) {
    this(pdbFilePath);
  }
  /**
   * @param isSplit Ignored
   * @deprecated isSplit parameter is ignored (4.0.0)
   */
  @Deprecated
  public AtomCache(String pdbFilePath, String cachePath, boolean isSplit) {
    this(pdbFilePath, cachePath);
  }

  /**
   * Creates a new AtomCache object based on the provided UserConfiguration.
   *
   * @param config the UserConfiguration to use for this cache.
   */
  public AtomCache(UserConfiguration config) {
    this(config.getPdbFilePath(), config.getCacheFilePath());
    fetchBehavior = config.getFetchBehavior();
    obsoleteBehavior = config.getObsoleteBehavior();
    useMmCif = config.getFileFormat().equals(UserConfiguration.MMCIF_FORMAT);
  }

  /**
   * Returns the CA atoms for the provided name. See {@link #getStructure(String)} for supported
   * naming conventions.
   *
   * <p>This method only works with protein chains. Use {@link #getRepresentativeAtoms(String)} for
   * a more general solution.
   *
   * @param name
   * @return an array of Atoms.
   * @throws IOException
   * @throws StructureException
   * @see
   */
  public Atom[] getAtoms(String name) throws IOException, StructureException {
    return getAtoms(new StructureName(name));
  }

  public Atom[] getAtoms(StructureIdentifier name) throws IOException, StructureException {

    Atom[] atoms = null;

    // System.out.println("loading " + name);
    Structure s = getStructure(name);

    atoms = StructureTools.getAtomCAArray(s);

    /*
     * synchronized (cache){ cache.put(name, atoms); }
     */

    return atoms;
  }
  /**
   * Returns the representative atoms for the provided name. See {@link #getStructure(String)} for
   * supported naming conventions.
   *
   * @param name
   * @return an array of Atoms.
   * @throws IOException
   * @throws StructureException
   * @see
   */
  public Atom[] getRepresentativeAtoms(String name) throws IOException, StructureException {
    return getRepresentativeAtoms(new StructureName(name));
  }

  public Atom[] getRepresentativeAtoms(StructureIdentifier name)
      throws IOException, StructureException {

    Atom[] atoms = null;

    Structure s = getStructure(name);

    atoms = StructureTools.getRepresentativeAtomArray(s);

    /*
     * synchronized (cache){ cache.put(name, atoms); }
     */

    return atoms;
  }
  /**
   * Loads the biological assembly for a given PDB ID and bioAssemblyId. If a bioAssemblyId > 0 is
   * specified, the corresponding biological assembly file will be loaded. Note, the number of
   * available biological unit files varies. Many entries don't have a biological assembly specified
   * (i.e. NMR structures), many entries have only one biological assembly (bioAssemblyId=1), and a
   * few structures have multiple biological assemblies. Set bioAssemblyFallback to true, to
   * download the original PDB file in cases that a biological assembly file is not available.
   *
   * @param pdbId the PDB ID
   * @param bioAssemblyId the 1-based index of the biological assembly (0 gets the asymmetric unit)
   * @param bioAssemblyFallback if true, try reading original PDB file in case the biological
   *     assembly file is not available
   * @return a structure object
   * @throws IOException
   * @throws StructureException
   * @author Peter Rose
   * @since 3.2
   */
  public Structure getBiologicalAssembly(
      String pdbId, int bioAssemblyId, boolean bioAssemblyFallback)
      throws StructureException, IOException {

    if (bioAssemblyId < 0) {
      throw new StructureException(
          "bioAssemblyID must be nonnegative: " + pdbId + " bioAssemblyId " + bioAssemblyId);
    }
    Structure s = StructureIO.getBiologicalAssembly(pdbId, bioAssemblyId, this);

    if (s == null && bioAssemblyFallback) return StructureIO.getBiologicalAssembly(pdbId, 0, this);

    return s;
  }

  /**
   * Loads the default biological unit (e.g. *.pdb1.gz). If it is not available, the asymmetric unit
   * will be loaded, i.e. for NMR structures.
   *
   * <p>Biological assemblies can also be accessed using <tt>getStructure("BIO:<i>[pdbId]</i>")</tt>
   *
   * @param pdbId the PDB ID
   * @return a structure object
   * @throws IOException
   * @throws StructureException
   * @since 4.2
   */
  public Structure getBiologicalAssembly(String pdbId) throws StructureException, IOException {
    int bioAssemblyId = 1;
    return getBiologicalAssembly(pdbId, bioAssemblyId);
  }
  /**
   * Loads the default biological unit (e.g. *.pdb1.gz). If it is not available, the asymmetric unit
   * will be loaded, i.e. for NMR structures.
   *
   * @param pdbId the PDB ID
   * @return a structure object
   * @throws IOException
   * @throws StructureException
   * @since 3.2
   * @deprecated Renamed to {@link #getBiologicalAssembly(String)} in 4.2
   */
  @Deprecated
  public Structure getBiologicalUnit(String pdbId) throws StructureException, IOException {
    return getBiologicalAssembly(pdbId);
  }
  /**
   * Loads the default biological unit (e.g. *.pdb1.gz). If it is not available, the asymmetric unit
   * will be loaded, i.e. for NMR structures.
   *
   * @param pdbId the PDB ID
   * @param bioAssemblyId the 1-based index of the biological assembly (0 gets the asymmetric unit)
   * @return a structure object
   * @throws IOException
   * @throws StructureException
   * @since 4.2
   */
  public Structure getBiologicalAssembly(String pdbId, int bioAssemblyId)
      throws StructureException, IOException {
    boolean bioAssemblyFallback = true;
    return getBiologicalAssembly(pdbId, bioAssemblyId, bioAssemblyFallback);
  }

  /**
   * Returns the path that contains the caching file for utility data, such as domain definitions.
   *
   * @return
   */
  public String getCachePath() {
    return cachePath;
  }

  public FileParsingParameters getFileParsingParams() {
    return params;
  }

  /**
   * Get the path that is used to cache PDB files.
   *
   * @return path to a directory
   */
  public String getPath() {
    return path;
  }

  public PDPProvider getPdpprovider() {
    return pdpprovider;
  }

  /**
   * Request a Structure based on a <i>name</i>.
   *
   * <pre>
   * 		Formal specification for how to specify the <i>name</i>:
   *
   * 		name     := pdbID
   * 		               | pdbID '.' chainID
   * 		               | pdbID '.' range
   * 		               | scopID
   * 		range         := '('? range (',' range)? ')'?
   * 		               | chainID
   * 		               | chainID '_' resNum '-' resNum
   * 		pdbID         := [0-9][a-zA-Z0-9]{3}
   * 		chainID       := [a-zA-Z0-9]
   * 		scopID        := 'd' pdbID [a-z_][0-9_]
   * 		resNum        := [-+]?[0-9]+[A-Za-z]?
   *
   *
   * 		Example structures:
   * 		1TIM     #whole structure
   * 		4HHB.C     #single chain
   * 		4GCR.A_1-83     #one domain, by residue number
   * 		3AA0.A,B     #two chains treated as one structure
   * 		d2bq6a1     #scop domain
   * </pre>
   *
   * With the additional set of rules:
   *
   * <ul>
   *   <li>If only a PDB code is provided, the whole structure will be return including ligands, but
   *       the first model only (for NMR).
   *   <li>Chain IDs are case sensitive, PDB ids are not. To specify a particular chain write as:
   *       4hhb.A or 4HHB.A
   *   <li>To specify a SCOP domain write a scopId e.g. d2bq6a1. Some flexibility can be allowed in
   *       SCOP domain names, see {@link #setStrictSCOP(boolean)}
   *   <li>URLs are accepted as well
   * </ul>
   *
   * <p>Note that this method should not be used in StructureIdentifier implementations to avoid
   * circular calls.
   *
   * @param name
   * @return a Structure object, or null if name appears improperly formated (eg too short, etc)
   * @throws IOException The PDB file cannot be cached due to IO errors
   * @throws StructureException The name appeared valid but did not correspond to a structure. Also
   *     thrown by some submethods upon errors, eg for poorly formatted subranges.
   */
  public Structure getStructure(String name) throws IOException, StructureException {
    StructureName structureName = new StructureName(name);

    return getStructure(structureName);
  }

  /**
   * Get the structure corresponding to the given {@link StructureIdentifier}. Equivalent to calling
   * {@link StructureIdentifier#loadStructure(AtomCache)} followed by {@link
   * StructureIdentifier#reduce(Structure)}.
   *
   * <p>Note that this method should not be used in StructureIdentifier implementations to avoid
   * circular calls.
   *
   * @param strucId
   * @return
   * @throws IOException
   * @throws StructureException
   */
  public Structure getStructure(StructureIdentifier strucId)
      throws IOException, StructureException {
    Structure s = strucId.loadStructure(this);
    Structure r = strucId.reduce(s);
    r.setStructureIdentifier(strucId);
    return r;

    //		if (name.length() < 4) {
    //			throw new IllegalArgumentException("Can't interpret IDs that are shorter than 4
    // characters!");
    //		}
    //
    //		Structure n = null;
    //
    //		boolean useChainNr = false;
    //		boolean useDomainInfo = false;
    //		String range = null;
    //		int chainNr = -1;
    //
    //
    //		StructureName structureName = new StructureName(name);
    //
    //		String pdbId = null;
    //		String chainId = null;
    //
    //		if (name.length() == 4) {
    //
    //			pdbId = name;
    //			Structure s;
    //			if (useMmCif) {
    //				s = loadStructureFromCifByPdbId(pdbId);
    //			} else {
    //				s = loadStructureFromPdbByPdbId(pdbId);
    //			}
    //			return s;
    //		} else if (structureName.isScopName()) {
    //
    //			// return based on SCOP domain ID
    //			return getStructureFromSCOPDomain(name);
    //		} else if (structureName.isCathID()) {
    //			return getStructureForCathDomain(structureName, CathFactory.getCathDatabase());
    //		} else if (name.length() == 6) {
    //			// name is PDB.CHAINID style (e.g. 4hhb.A)
    //
    //			pdbId = name.substring(0, 4);
    //			if (name.substring(4, 5).equals(CHAIN_SPLIT_SYMBOL)) {
    //				chainId = name.substring(5, 6);
    //			} else if (name.substring(4, 5).equals(CHAIN_NR_SYMBOL)) {
    //
    //				useChainNr = true;
    //				chainNr = Integer.parseInt(name.substring(5, 6));
    //			}
    //
    //		} else if (name.startsWith("file:/") || name.startsWith("http:/")) {
    //			// this is a URL
    //
    //			URL url = new URL(name);
    //			return getStructureFromURL(url);
    //
    //
    //		} else if (structureName.isPDPDomain()) {
    //
    //			// this is a PDP domain definition
    //
    //			return getPDPStructure(name);
    //
    //		} else if (name.startsWith(BIOL_ASSEMBLY_IDENTIFIER)) {
    //
    //			return getBioAssembly(name);
    //
    //		} else if (name.length() > 6 && !name.startsWith(PDP_DOMAIN_IDENTIFIER)
    //				&& (name.contains(CHAIN_NR_SYMBOL) || name.contains(UNDERSCORE))
    //				&& !(name.startsWith("file:/") || name.startsWith("http:/"))
    //
    //				) {
    //
    //			// this is a name + range
    //
    //			pdbId = name.substring(0, 4);
    //			// this ID has domain split information...
    //			useDomainInfo = true;
    //			range = name.substring(5);
    //
    //		}
    //
    //		// System.out.println("got: >" + name + "< " + pdbId + " " + chainId + " useChainNr:" +
    // useChainNr + " "
    //		// +chainNr + " useDomainInfo:" + useDomainInfo + " " + range);
    //
    //		if (pdbId == null) {
    //
    //			return null;
    //		}
    //
    //		while (checkLoading(pdbId)) {
    //			// waiting for loading to be finished...
    //
    //			try {
    //				Thread.sleep(100);
    //			} catch (InterruptedException e) {
    //				logger.error(e.getMessage());
    //			}
    //
    //		}
    //
    //		// long start = System.currentTimeMillis();
    //
    //		Structure s;
    //		if (useMmCif) {
    //			s = loadStructureFromCifByPdbId(pdbId);
    //		} else {
    //			s = loadStructureFromPdbByPdbId(pdbId);
    //		}
    //
    //		// long end = System.currentTimeMillis();
    //		// System.out.println("time to load " + pdbId + " " + (end-start) + "\t  size :" +
    //		// StructureTools.getNrAtoms(s) + "\t cached: " + cache.size());
    //
    //		if (chainId == null && chainNr < 0 && range == null) {
    //			// we only want the 1st model in this case
    //			n = StructureTools.getReducedStructure(s, -1);
    //		} else {
    //
    //			if (useChainNr) {
    //				// System.out.println("using ChainNr");
    //				n = StructureTools.getReducedStructure(s, chainNr);
    //			} else if (useDomainInfo) {
    //				// System.out.println("calling getSubRanges");
    //				n = StructureTools.getSubRanges(s, range);
    //			} else {
    //				// System.out.println("reducing Chain Id " + chainId);
    //				n = StructureTools.getReducedStructure(s, chainId);
    //			}
    //		}
    //
    //
    //
    //		n.setName(name);
    //		return n;

  }

  /**
   * Returns the representation of a {@link ScopDomain} as a BioJava {@link Structure} object.
   *
   * @param domain a SCOP domain
   * @return a Structure object
   * @throws IOException
   * @throws StructureException
   */
  public Structure getStructureForDomain(ScopDomain domain) throws IOException, StructureException {
    return getStructureForDomain(domain, ScopFactory.getSCOP());
  }

  /**
   * Returns the representation of a {@link ScopDomain} as a BioJava {@link Structure} object.
   *
   * @param domain a SCOP domain
   * @param scopDatabase A {@link ScopDatabase} to use
   * @return a Structure object
   * @throws IOException
   * @throws StructureException
   */
  public Structure getStructureForDomain(ScopDomain domain, ScopDatabase scopDatabase)
      throws IOException, StructureException {
    return getStructureForDomain(domain, scopDatabase, false);
  }

  /**
   * Returns the representation of a {@link ScopDomain} as a BioJava {@link Structure} object.
   *
   * @param domain a SCOP domain
   * @param scopDatabase A {@link ScopDatabase} to use
   * @param strictLigandHandling If set to false, hetero-atoms are included if and only if they
   *     belong to a chain to which the SCOP domain belongs; if set to true, hetero-atoms are
   *     included if and only if they are strictly within the definition (residue numbers) of the
   *     SCOP domain
   * @return a Structure object
   * @throws IOException
   * @throws StructureException
   */
  public Structure getStructureForDomain(
      ScopDomain domain, ScopDatabase scopDatabase, boolean strictLigandHandling)
      throws IOException, StructureException {

    String pdbId = domain.getPdbId();
    Structure fullStructure = getStructureForPdbId(pdbId);
    Structure structure = domain.reduce(fullStructure);

    // TODO It would be better to move all of this into the reduce method,
    // but that would require ligand handling properties in StructureIdentifiers

    // because ligands sometimes occur after TER records in PDB files, we may need to add some
    // ligands back in
    // specifically, we add a ligand if and only if it occurs within the domain
    AtomPositionMap map = null;
    List<ResidueRangeAndLength> rrs = null;
    if (strictLigandHandling) {
      map =
          new AtomPositionMap(
              StructureTools.getAllAtomArray(fullStructure), AtomPositionMap.ANYTHING_MATCHER);
      rrs = ResidueRangeAndLength.parseMultiple(domain.getRanges(), map);
    }
    for (Chain chain : fullStructure.getChains()) {
      if (!structure.hasChain(chain.getChainID())) {
        continue; // we can't do anything with a chain our domain
      }
      // doesn't contain
      Chain newChain = structure.getChainByPDB(chain.getChainID());
      List<Group> ligands = StructureTools.filterLigands(chain.getAtomGroups());
      for (Group group : ligands) {
        boolean shouldContain = true;
        if (strictLigandHandling) {
          shouldContain = false; // whether the ligand occurs within the domain
          for (ResidueRange rr : rrs) {
            if (rr.contains(group.getResidueNumber(), map)) {
              shouldContain = true;
            }
          }
        }
        boolean alreadyContains =
            newChain.getAtomGroups().contains(group); // we don't want to add duplicate
        // ligands
        if (shouldContain && !alreadyContains) {
          newChain.addGroup(group);
        }
      }
    }

    // build a more meaningful description for the new structure
    StringBuilder header = new StringBuilder();
    header.append(domain.getClassificationId());
    if (scopDatabase != null) {
      int sf = domain.getSuperfamilyId();
      ScopDescription description = scopDatabase.getScopDescriptionBySunid(sf);
      if (description != null) {
        header.append(" | ");
        header.append(description.getDescription());
      }
    }
    structure.getPDBHeader().setDescription(header.toString());

    return structure;
  }

  /**
   * Returns the representation of a {@link ScopDomain} as a BioJava {@link Structure} object.
   *
   * @param scopId a SCOP Id
   * @return a Structure object
   * @throws IOException
   * @throws StructureException
   */
  public Structure getStructureForDomain(String scopId) throws IOException, StructureException {
    return getStructureForDomain(scopId, ScopFactory.getSCOP());
  }

  /**
   * Returns the representation of a {@link ScopDomain} as a BioJava {@link Structure} object.
   *
   * @param scopId a SCOP Id
   * @param scopDatabase A {@link ScopDatabase} to use
   * @return a Structure object
   * @throws IOException
   * @throws StructureException
   */
  public Structure getStructureForDomain(String scopId, ScopDatabase scopDatabase)
      throws IOException, StructureException {
    ScopDomain domain = scopDatabase.getDomainByScopID(scopId);
    return getStructureForDomain(domain, scopDatabase);
  }

  /**
   * Does the cache automatically download files that are missing from the local installation from
   * the PDB FTP site?
   *
   * @return flag
   * @deprecated Use {@link #getFetchBehavior()}
   */
  @Deprecated
  public boolean isAutoFetch() {
    return fetchBehavior != FetchBehavior.LOCAL_ONLY;
  }

  /**
   * <b>N.B.</b> This feature won't work unless the structure wasn't found & autoFetch is set to
   * <code>true</code>.
   *
   * @return the fetchCurrent
   * @deprecated Use {@link FileParsingParameters#getObsoleteBehavior()} instead (4.0.0)
   */
  @Deprecated
  public boolean isFetchCurrent() {
    return getObsoleteBehavior() == ObsoleteBehavior.FETCH_CURRENT;
  }

  /**
   * forces the cache to fetch the file if its status is OBSOLETE. This feature has a higher
   * priority than {@link #setFetchCurrent(boolean)}.<br>
   * <b>N.B.</b> This feature won't work unless the structure wasn't found & autoFetch is set to
   * <code>true</code>.
   *
   * @return the fetchFileEvenIfObsolete
   * @author Amr AL-Hossary
   * @see #fetchCurrent
   * @since 3.0.2
   * @deprecated Use {@link FileParsingParameters#getObsoleteBehavior()} instead (4.0.0)
   */
  @Deprecated
  public boolean isFetchFileEvenIfObsolete() {
    return getObsoleteBehavior() == ObsoleteBehavior.FETCH_OBSOLETE;
  }

  /**
   * Scop handling was changed in 4.2.0. For behaviour equivalent to strictSCOP==true, use {@link
   * ScopDatabase#getDomainByScopID(String)}. For strictSCOP==False, create a {@link StructureName}
   * or use {@link StructureName#guessScopDomain(String, ScopDatabase)} explicitely.
   *
   * @return false; ignored
   * @deprecated since 4.2
   */
  @Deprecated
  public boolean isStrictSCOP() {
    return false;
  }

  /**
   * Send a signal to the cache that the system is shutting down. Notifies underlying
   * SerializableCache instances to flush themselves...
   */
  public void notifyShutdown() {
    // System.out.println(" AtomCache got notify shutdown..");
    if (pdpprovider != null) {
      if (pdpprovider instanceof RemotePDPProvider) {
        RemotePDPProvider remotePDP = (RemotePDPProvider) pdpprovider;
        remotePDP.flushCache();
      }
    }

    // todo: use a SCOP implementation that is backed by SerializableCache
    ScopDatabase scopInstallation = ScopFactory.getSCOP();
    if (scopInstallation != null) {
      if (scopInstallation instanceof CachedRemoteScopInstallation) {
        CachedRemoteScopInstallation cacheScop = (CachedRemoteScopInstallation) scopInstallation;
        cacheScop.flushCache();
      }
    }
  }

  /**
   * Does the cache automatically download files that are missing from the local installation from
   * the PDB FTP site?
   *
   * @param autoFetch flag
   * @deprecated Use {@link #getFetchBehavior()}
   */
  @Deprecated
  public void setAutoFetch(boolean autoFetch) {
    if (autoFetch) {
      setFetchBehavior(FetchBehavior.DEFAULT);
    } else {
      setFetchBehavior(FetchBehavior.LOCAL_ONLY);
    }
  }

  /**
   * set the location at which utility data should be cached.
   *
   * @param cachePath
   */
  public void setCachePath(String cachePath) {
    this.cachePath = cachePath;
  }

  /**
   * if enabled, the reader searches for the newest possible PDB ID, if not present in he local
   * installation. The {@link #setFetchFileEvenIfObsolete(boolean)} function has a higher priority
   * than this function.<br>
   * <b>N.B.</b> This feature won't work unless the structure wasn't found & autoFetch is set to
   * <code>true</code>.
   *
   * @param fetchCurrent the fetchCurrent to set
   * @author Amr AL-Hossary
   * @see #setFetchFileEvenIfObsolete(boolean)
   * @since 3.0.2
   * @deprecated Use {@link FileParsingParameters#setObsoleteBehavior()} instead (4.0.0)
   */
  @Deprecated
  public void setFetchCurrent(boolean fetchNewestCurrent) {
    if (fetchNewestCurrent) {
      setObsoleteBehavior(ObsoleteBehavior.FETCH_CURRENT);
    } else {
      if (getObsoleteBehavior() == ObsoleteBehavior.FETCH_CURRENT) {
        setObsoleteBehavior(ObsoleteBehavior.DEFAULT);
      }
    }
  }

  /**
   * <b>N.B.</b> This feature won't work unless the structure wasn't found & autoFetch is set to
   * <code>true</code>.
   *
   * @param fetchFileEvenIfObsolete the fetchFileEvenIfObsolete to set
   * @deprecated Use {@link FileParsingParameters#setObsoleteBehavior()} instead (4.0.0)
   */
  @Deprecated
  public void setFetchFileEvenIfObsolete(boolean fetchFileEvenIfObsolete) {
    if (fetchFileEvenIfObsolete) {
      setObsoleteBehavior(ObsoleteBehavior.FETCH_OBSOLETE);
    } else {
      if (getObsoleteBehavior() == ObsoleteBehavior.FETCH_OBSOLETE) {
        setObsoleteBehavior(ObsoleteBehavior.DEFAULT);
      }
    }
  }

  public void setFileParsingParams(FileParsingParameters params) {
    this.params = params;
  }

  /**
   * <b>[Optional]</b> This method changes the behavior when obsolete entries are requested. Current
   * behaviors are:
   *
   * <ul>
   *   <li>{@link ObsoleteBehavior#THROW_EXCEPTION THROW_EXCEPTION} Throw a {@link
   *       StructureException} (the default)
   *   <li>{@link ObsoleteBehavior#FETCH_OBSOLETE FETCH_OBSOLETE} Load the requested ID from the
   *       PDB's obsolete repository
   *   <li>{@link ObsoleteBehavior#FETCH_CURRENT FETCH_CURRENT} Load the most recent version of the
   *       requested structure
   *       <p>This setting may be silently ignored by implementations which do not have access to
   *       the server to determine whether an entry is obsolete, such as if {@link #isAutoFetch()}
   *       is false. Note that an obsolete entry may still be returned even this is FETCH_CURRENT if
   *       the entry is found locally.
   *
   * @param fetchFileEvenIfObsolete Whether to fetch obsolete records
   * @see #setFetchCurrent(boolean)
   * @since 4.0.0
   */
  public void setObsoleteBehavior(ObsoleteBehavior behavior) {
    obsoleteBehavior = behavior;
  }

  /**
   * Returns how this instance deals with obsolete entries. Note that this setting may be ignored by
   * some implementations or in some situations, such as when {@link #isAutoFetch()} is false.
   *
   * <p>For most implementations, the default value is {@link ObsoleteBehavior#THROW_EXCEPTION
   * THROW_EXCEPTION}.
   *
   * @return The ObsoleteBehavior
   * @since 4.0.0
   */
  public ObsoleteBehavior getObsoleteBehavior() {
    return obsoleteBehavior;
  }

  /**
   * Get the behavior for fetching files from the server
   *
   * @return
   */
  public FetchBehavior getFetchBehavior() {
    return fetchBehavior;
  }
  /**
   * Set the behavior for fetching files from the server
   *
   * @param fetchBehavior
   */
  public void setFetchBehavior(FetchBehavior fetchBehavior) {
    this.fetchBehavior = fetchBehavior;
  }

  /**
   * Set the path that is used to cache PDB files.
   *
   * @param path to a directory
   */
  public void setPath(String path) {
    this.path = FileDownloadUtils.expandUserHome(path);
  }

  public void setPdpprovider(PDPProvider pdpprovider) {
    this.pdpprovider = pdpprovider;
  }

  /**
   * This method does nothing.
   *
   * <p>Scop handling was changed in 4.2.0. For behaviour equivalent to strictSCOP==true, use {@link
   * ScopDatabase#getDomainByScopID(String)}. For strictSCOP==False, create a {@link StructureName}
   * or use {@link StructureName#guessScopDomain(String, ScopDatabase)} explicitely.
   *
   * @param strictSCOP Ignored
   * @deprecated Removed in 4.2.0
   */
  @Deprecated
  public void setStrictSCOP(boolean ignored) {}

  /** @return the useMmCif */
  public boolean isUseMmCif() {
    return useMmCif;
  }

  /** @param useMmCif the useMmCif to set */
  public void setUseMmCif(boolean useMmCif) {
    this.useMmCif = useMmCif;

    if (useMmCif) {
      // get bio assembly from mmcif file

      BioUnitDataProviderFactory.setBioUnitDataProvider(MmCifBiolAssemblyProvider.class);

    } else {

      BioUnitDataProviderFactory.setBioUnitDataProvider(PDBBioUnitDataProvider.class);
    }
  }

  private boolean checkLoading(String name) {
    return currentlyLoading.contains(name);
  }

  /**
   * Returns a {@link Structure} corresponding to the CATH identifier supplied in {@code
   * structureName}, using the the {@link CathDatabase} at {@link CathFactory#getCathDatabase()}.
   */
  public Structure getStructureForCathDomain(StructureName structureName)
      throws IOException, StructureException {
    return getStructureForCathDomain(structureName, CathFactory.getCathDatabase());
  }

  /**
   * Returns a {@link Structure} corresponding to the CATH identifier supplied in {@code
   * structureName}, using the specified {@link CathDatabase}.
   */
  public Structure getStructureForCathDomain(StructureName structureName, CathDatabase cathInstall)
      throws IOException, StructureException {

    CathDomain cathDomain = cathInstall.getDomainByCathId(structureName.getIdentifier());

    Structure s = getStructureForPdbId(cathDomain.getIdentifier());
    Structure n = cathDomain.reduce(s);

    // add the ligands of the chain...

    Chain newChain = n.getChainByPDB(structureName.getChainId());
    Chain origChain = s.getChainByPDB(structureName.getChainId());
    List<Group> ligands = origChain.getAtomLigands();

    for (Group g : ligands) {
      if (!newChain.getAtomGroups().contains(g)) {
        newChain.addGroup(g);
      }
    }

    return n;
  }

  protected void flagLoading(String name) {
    if (!currentlyLoading.contains(name)) {

      currentlyLoading.add(name);
    }
  }

  protected void flagLoadingFinished(String name) {

    currentlyLoading.remove(name);
  }

  /**
   * Loads a structure directly by PDB ID
   *
   * @param pdbId
   * @return
   * @throws IOException
   * @throws StructureException
   */
  public Structure getStructureForPdbId(String pdbId) throws IOException, StructureException {
    if (pdbId == null) return null;
    if (pdbId.length() != 4) {
      throw new StructureException("Unrecognized PDB ID: " + pdbId);
    }
    while (checkLoading(pdbId)) {
      // waiting for loading to be finished...

      try {
        Thread.sleep(100);
      } catch (InterruptedException e) {
        logger.error(e.getMessage());
      }
    }

    Structure s;
    if (useMmCif) {
      s = loadStructureFromCifByPdbId(pdbId);
    } else {
      s = loadStructureFromPdbByPdbId(pdbId);
    }
    return s;
  }

  protected Structure loadStructureFromCifByPdbId(String pdbId)
      throws IOException, StructureException {

    Structure s;
    flagLoading(pdbId);
    try {
      MMCIFFileReader reader = new MMCIFFileReader(path);
      reader.setFetchBehavior(fetchBehavior);
      reader.setObsoleteBehavior(obsoleteBehavior);

      reader.setFileParsingParameters(params);

      s = reader.getStructureById(pdbId.toLowerCase());

    } finally {
      flagLoadingFinished(pdbId);
    }

    return s;
  }

  protected Structure loadStructureFromPdbByPdbId(String pdbId)
      throws IOException, StructureException {

    Structure s;
    flagLoading(pdbId);
    try {
      PDBFileReader reader = new PDBFileReader(path);
      reader.setFetchBehavior(fetchBehavior);
      reader.setObsoleteBehavior(obsoleteBehavior);

      reader.setFileParsingParameters(params);

      s = reader.getStructureById(pdbId.toLowerCase());

    } finally {
      flagLoadingFinished(pdbId);
    }

    return s;
  }
}
 public CollectElements(Collection<PsiReference> collection) {
   myCollection = Collections.synchronizedCollection(collection);
 }
 private IdleConnectionMonitorThread() {
   connMgrs = new ArrayList<HttpClientConnectionManager>();
   Collections.synchronizedCollection(connMgrs);
   isblock = new AtomicBoolean(true);
   start();
 };
Esempio n. 13
0
  /**
   * BundleLoader runtime constructor. This object is created lazily when the first request for a
   * resource is made to this bundle.
   *
   * @param bundle Bundle object for this loader.
   * @param proxy the BundleLoaderProxy for this loader.
   * @exception org.osgi.framework.BundleException
   */
  protected BundleLoader(BundleHost bundle, BundleLoaderProxy proxy) throws BundleException {
    this.bundle = bundle;
    this.proxy = proxy;
    try {
      bundle.getBundleData().open(); /* make sure the BundleData is open */
    } catch (IOException e) {
      throw new BundleException(Msg.BUNDLE_READ_EXCEPTION, e);
    }
    BundleDescription description = proxy.getBundleDescription();
    // init the require bundles list.
    BundleDescription[] required = description.getResolvedRequires();
    if (required.length > 0) {
      // get a list of re-exported symbolic names
      HashSet reExportSet = new HashSet(required.length);
      BundleSpecification[] requiredSpecs = description.getRequiredBundles();
      if (requiredSpecs != null && requiredSpecs.length > 0)
        for (int i = 0; i < requiredSpecs.length; i++)
          if (requiredSpecs[i].isExported()) reExportSet.add(requiredSpecs[i].getName());

      requiredBundles = new BundleLoaderProxy[required.length];
      int[] reexported = new int[required.length];
      int reexportIndex = 0;
      for (int i = 0; i < required.length; i++) {
        requiredBundles[i] = getLoaderProxy(required[i]);
        if (reExportSet.contains(required[i].getSymbolicName())) reexported[reexportIndex++] = i;
      }
      if (reexportIndex > 0) {
        reexportTable = new int[reexportIndex];
        System.arraycopy(reexported, 0, reexportTable, 0, reexportIndex);
      } else {
        reexportTable = null;
      }
      requiredSources = new KeyedHashSet(10, false);
    } else {
      requiredBundles = null;
      reexportTable = null;
      requiredSources = null;
    }

    // init the provided packages set
    ExportPackageDescription[] exports = description.getSelectedExports();
    if (exports != null && exports.length > 0) {
      exportedPackages =
          Collections.synchronizedCollection(
              exports.length > 10
                  ? (Collection) new HashSet(exports.length)
                  : new ArrayList(exports.length));
      initializeExports(exports, exportedPackages);
    } else {
      exportedPackages = Collections.synchronizedCollection(new ArrayList(0));
    }

    ExportPackageDescription substituted[] = description.getSubstitutedExports();
    if (substituted.length > 0) {
      substitutedPackages =
          substituted.length > 10
              ? (Collection) new HashSet(substituted.length)
              : new ArrayList(substituted.length);
      for (int i = 0; i < substituted.length; i++)
        substitutedPackages.add(substituted[i].getName());
    } else {
      substitutedPackages = null;
    }

    // This is the fastest way to access to the description for fragments since the
    // hostdescription.getFragments() is slow
    BundleFragment[] fragmentObjects = bundle.getFragments();
    BundleDescription[] fragments =
        new BundleDescription[fragmentObjects == null ? 0 : fragmentObjects.length];
    for (int i = 0; i < fragments.length; i++)
      fragments[i] = fragmentObjects[i].getBundleDescription();
    // init the dynamic imports tables
    if (description.hasDynamicImports()) addDynamicImportPackage(description.getImportPackages());
    // ...and its fragments
    for (int i = 0; i < fragments.length; i++)
      if (fragments[i].isResolved() && fragments[i].hasDynamicImports())
        addDynamicImportPackage(fragments[i].getImportPackages());

    // Initialize the policy handler
    String buddyList = null;
    try {
      buddyList = (String) bundle.getBundleData().getManifest().get(Constants.BUDDY_LOADER);
    } catch (BundleException e) {
      // do nothing; buddyList == null
    }
    policy =
        buddyList != null
            ? new PolicyHandler(this, buddyList, bundle.getFramework().getPackageAdmin())
            : null;
    if (policy != null) policy.open(bundle.getFramework().getSystemBundleContext());
  }
Esempio n. 14
0
 /**
  * Covariant function so the compiler can choose the proper one at compile time, eliminates the
  * need for XDoclet to really understand compiletime typing.
  *
  * <p>Read only collections need to be synchronized. Once we start giving out handles to these
  * collections, they'll be used in other threads sooner or later.
  */
 private static java.util.Collection wrapCollection(java.util.Collection input) {
   return java.util.Collections.synchronizedCollection(input);
 }
Esempio n. 15
0
/**
 * Class for prototyping database connections. Prototype only -- hardcoded for mysql, connects to
 * single database, keeps single connection, etc.
 *
 * @author Jim Robinson
 * @date 10/31/11
 */
public class DBManager {

  private static Logger log = Logger.getLogger(DBManager.class);

  static Collection<ConnectionWrapper> connectionPool =
      Collections.synchronizedCollection(new ArrayList<ConnectionWrapper>());
  static String username;
  static String password;

  public static Connection getConnection() {

    Iterator<ConnectionWrapper> poolIter = connectionPool.iterator();
    while (poolIter.hasNext()) {
      ConnectionWrapper conn = poolIter.next();
      try {
        if (conn == null || conn.isReallyClosed()) {
          poolIter.remove();
        } else if (!conn.isClosed()) {
          return conn;
        }
      } catch (SQLException e) {
        log.error("Bad connection", e);
        poolIter.remove();
      }
    }

    // No valid connections
    ConnectionWrapper conn = createConnection();
    if (conn != null) {
      connectionPool.add(conn);
      log.info("Connection pool size: " + connectionPool.size());
    }
    return conn;
  }

  private static ConnectionWrapper createConnection() {
    String driver = "com.mysql.jdbc.Driver";
    try {
      Class.forName(driver).newInstance();
    } catch (Exception e) {
      e.printStackTrace();
    }

    final PreferenceManager preferenceManager = PreferenceManager.getInstance();
    String host = preferenceManager.get(PreferenceManager.DB_HOST);
    String db = preferenceManager.get(PreferenceManager.DB_NAME);
    String port = preferenceManager.get(PreferenceManager.DB_PORT);

    String url = "jdbc:mysql://" + host;
    if (!port.equals("-1")) {
      url += ":" + port;
    }
    url += "/" + db;

    return connect(url);
  }

  private static ConnectionWrapper connect(String url) {
    try {
      return new ConnectionWrapper(DriverManager.getConnection(url, username, password));
    } catch (SQLException e) {
      int errorCode = e.getErrorCode();
      if (errorCode == 1044 || errorCode == 1045) {
        String host = PreferenceManager.getInstance().get(PreferenceManager.DB_HOST);

        Frame parent = Globals.isHeadless() ? null : IGV.getMainFrame();
        LoginDialog dlg = new LoginDialog(parent, false, host, false);
        dlg.setVisible(true);
        if (dlg.isCanceled()) {
          throw new RuntimeException("Must login to access" + host);
        }
        username = dlg.getUsername();
        password = new String(dlg.getPassword());
        return connect(url);

      } else {
        MessageUtils.showMessage("<html>Error connecting to database: <br>" + e.getMessage());
        return null;
      }
    }
  }

  public static void shutdown() {
    for (ConnectionWrapper conn : connectionPool) {
      if (conn != null) {
        try {
          conn.reallyClose();
        } catch (SQLException e) {

        }
      }
    }
    connectionPool.clear();
  }

  static class ConnectionWrapper implements Connection {

    Connection conn;
    boolean closed;

    ConnectionWrapper(Connection conn) {
      this.conn = conn;
      closed = false;
    }

    public void close() throws SQLException {
      closed = true;
    }

    public boolean isClosed() throws SQLException {
      return closed;
    }

    public void reallyClose() throws SQLException {
      closed = true;
      conn.close();
    }

    public boolean isReallyClosed() throws SQLException {
      return conn.isClosed();
    }

    public void clearWarnings() throws SQLException {
      conn.clearWarnings();
    }

    public void commit() throws SQLException {
      conn.commit();
    }

    public Array createArrayOf(String s, Object[] objects) throws SQLException {
      return conn.createArrayOf(s, objects);
    }

    public Blob createBlob() throws SQLException {
      return conn.createBlob();
    }

    public Clob createClob() throws SQLException {
      return conn.createClob();
    }

    public NClob createNClob() throws SQLException {
      return conn.createNClob();
    }

    public SQLXML createSQLXML() throws SQLException {
      return conn.createSQLXML();
    }

    public Statement createStatement() throws SQLException {
      return conn.createStatement();
    }

    public Statement createStatement(int i, int i1) throws SQLException {
      return conn.createStatement(i, i1);
    }

    public Statement createStatement(int i, int i1, int i2) throws SQLException {
      return conn.createStatement(i, i1, i2);
    }

    public Struct createStruct(String s, Object[] objects) throws SQLException {
      return conn.createStruct(s, objects);
    }

    public void setSchema(String schema) throws SQLException {
      throw new UnsupportedOperationException(
          "Operation not supported for backwards compatibility to Java 6");
    }

    public String getSchema() throws SQLException {
      return null; // TODO
    }

    public void abort(Executor executor) throws SQLException {
      throw new UnsupportedOperationException(
          "Operation not supported for backwards compatibility to Java 6");
    }

    public void setNetworkTimeout(Executor executor, int milliseconds) throws SQLException {
      throw new UnsupportedOperationException(
          "Operation not supported for backwards compatibility to Java 6");
    }

    public int getNetworkTimeout() {
      return -1;
    }

    public boolean getAutoCommit() throws SQLException {
      return conn.getAutoCommit();
    }

    public String getCatalog() throws SQLException {
      return conn.getCatalog();
    }

    public Properties getClientInfo() throws SQLException {
      return conn.getClientInfo();
    }

    public String getClientInfo(String s) throws SQLException {
      return conn.getClientInfo(s);
    }

    public int getHoldability() throws SQLException {
      return conn.getHoldability();
    }

    public DatabaseMetaData getMetaData() throws SQLException {
      return conn.getMetaData();
    }

    public int getTransactionIsolation() throws SQLException {
      return conn.getTransactionIsolation();
    }

    public Map<String, Class<?>> getTypeMap() throws SQLException {
      return conn.getTypeMap();
    }

    public SQLWarning getWarnings() throws SQLException {
      return conn.getWarnings();
    }

    public boolean isReadOnly() throws SQLException {
      return conn.isReadOnly();
    }

    public boolean isValid(int i) throws SQLException {
      return conn.isValid(i);
    }

    public String nativeSQL(String s) throws SQLException {
      return conn.nativeSQL(s);
    }

    public CallableStatement prepareCall(String s) throws SQLException {
      return conn.prepareCall(s);
    }

    public CallableStatement prepareCall(String s, int i, int i1) throws SQLException {
      return conn.prepareCall(s, i, i1);
    }

    public CallableStatement prepareCall(String s, int i, int i1, int i2) throws SQLException {
      return conn.prepareCall(s, i, i1, i2);
    }

    public PreparedStatement prepareStatement(String s) throws SQLException {
      return conn.prepareStatement(s);
    }

    public PreparedStatement prepareStatement(String s, int i) throws SQLException {
      return conn.prepareStatement(s, i);
    }

    public PreparedStatement prepareStatement(String s, int i, int i1) throws SQLException {
      return conn.prepareStatement(s, i, i1);
    }

    public PreparedStatement prepareStatement(String s, int i, int i1, int i2) throws SQLException {
      return conn.prepareStatement(s, i, i1, i2);
    }

    public PreparedStatement prepareStatement(String s, int[] ints) throws SQLException {
      return conn.prepareStatement(s, ints);
    }

    public PreparedStatement prepareStatement(String s, String[] strings) throws SQLException {
      return conn.prepareStatement(s, strings);
    }

    public void releaseSavepoint(Savepoint savepoint) throws SQLException {
      conn.releaseSavepoint(savepoint);
    }

    public void rollback() throws SQLException {
      conn.rollback();
    }

    public void rollback(Savepoint savepoint) throws SQLException {
      conn.rollback(savepoint);
    }

    public void setAutoCommit(boolean b) throws SQLException {
      conn.setAutoCommit(b);
    }

    public void setCatalog(String s) throws SQLException {
      conn.setCatalog(s);
    }

    public void setClientInfo(Properties properties) throws SQLClientInfoException {
      conn.setClientInfo(properties);
    }

    public void setClientInfo(String s, String s1) throws SQLClientInfoException {
      conn.setClientInfo(s, s1);
    }

    public void setHoldability(int i) throws SQLException {
      conn.setHoldability(i);
    }

    public void setReadOnly(boolean b) throws SQLException {
      conn.setReadOnly(b);
    }

    public Savepoint setSavepoint() throws SQLException {
      return conn.setSavepoint();
    }

    public Savepoint setSavepoint(String s) throws SQLException {
      return conn.setSavepoint(s);
    }

    public void setTransactionIsolation(int i) throws SQLException {
      conn.setTransactionIsolation(i);
    }

    public void setTypeMap(Map<String, Class<?>> stringClassMap) throws SQLException {
      conn.setTypeMap(stringClassMap);
    }

    public boolean isWrapperFor(Class<?> aClass) throws SQLException {
      return conn.isWrapperFor(aClass);
    }

    public <T> T unwrap(Class<T> tClass) throws SQLException {
      return conn.unwrap(tClass);
    }
  }
}