/** * Internal constructor. * * @param smarts pattern * @param builder the builder * @throws IOException the pattern could not be parsed */ private SmartsPattern(final String smarts, IChemObjectBuilder builder) throws IOException { this.query = new QueryAtomContainer(null); if (!Smarts.parse(query, smarts)) throw new IOException("Could not parse SMARTS: " + smarts); this.pattern = Pattern.findSubstructure(query); }
@Override public String toString() { StringBuilder s = new StringBuilder(); s.append("QueryAtomContainer("); s.append(this.hashCode()); s.append(", #A:").append(getAtomCount()); s.append(", #EC:").append(getElectronContainerCount()); for (int i = 0; i < getAtomCount(); i++) { s.append(", ").append(getAtom(i).toString()); } for (int i = 0; i < getBondCount(); i++) { s.append(", ").append(getBond(i).toString()); } for (int i = 0; i < getLonePairCount(); i++) { s.append(", ").append(getLonePair(i).toString()); } for (int i = 0; i < getSingleElectronCount(); i++) { s.append(", ").append(getSingleElectron(i).toString()); } s.append(')'); return s.toString(); }
/** * Adds a bond to this container. * *@param atom1 Id of the first atom of the Bond in [0,..] *@param atom2 Id of the second atom of the Bond in [0,..] *@param order Bondorder */ @Override public void addBond(int atom1, int atom2, IBond.Order order) { IBond bond = getBuilder().newInstance(IBond.class, getAtom(atom1), getAtom(atom2), order); if (bondCount >= bonds.length) { growBondArray(); } addBond(bond); /* * no notifyChanged() here because addBond(bond) does it already */ }
/** * Removes the bond from this container. * * @param bond The bond to be removed. */ @Override public void removeBond(IBond bond) { int pos = getBondNumber(bond); if (pos != -1) removeBond(pos); }
/** * Adds a ElectronContainer to this AtomContainer. * *@param electronContainer The ElectronContainer to added to this container */ @Override public void addElectronContainer(IElectronContainer electronContainer) { if (electronContainer instanceof IBond) this.addBond((IBond) electronContainer); if (electronContainer instanceof ILonePair) this.addLonePair((ILonePair) electronContainer); if (electronContainer instanceof ISingleElectron) this.addSingleElectron((ISingleElectron) electronContainer); }
/** * {@inheritDoc} */ @Override public void removeAtom(int pos) { removeAtom(getAtom(pos)); }
@Test public void atomStereoReordered2() { QueryAtomContainer mol = new QueryAtomContainer(null); assertTrue(Smarts.parse(mol, "C[C@H](O)CC")); IAtom[] atoms = AtomContainerManipulator.getAtomArray(mol); swap(atoms, 0, 1); mol.setAtoms(atoms); assertThat(Smarts.generate(mol), is("[C@@H1](C)(O)CC")); }
public static QueryAtomContainer createSymbolChargeIDQueryContainer(IAtomContainer container) { QueryAtomContainer queryContainer = new QueryAtomContainer(container.getBuilder()); for (int i = 0; i < container.getAtomCount(); i++) { queryContainer.addAtom(new SymbolChargeIDQueryAtom(container.getAtom(i))); } Iterator<IBond> bonds = container.bonds().iterator(); while (bonds.hasNext()) { IBond bond = bonds.next(); int index1 = container.indexOf(bond.getBegin()); int index2 = container.indexOf(bond.getEnd()); if (bond.isAromatic()) { QueryBond qbond = new QueryBond(queryContainer.getAtom(index1), queryContainer.getAtom(index2), Expr.Type.IS_AROMATIC); queryContainer.addBond(qbond); } else { QueryBond qbond = new QueryBond(queryContainer.getAtom(index1), queryContainer.getAtom(index2), Expr.Type.ORDER, bond.getOrder().numeric()); qbond.setOrder(bond.getOrder()); // backwards compatibility queryContainer.addBond(qbond); } } return queryContainer; }
/** * Removes all atoms and bond from this container. */ @Override public void removeAllElements() { removeAllElectronContainers(); for (int f = 0; f < getAtomCount(); f++) { getAtom(f).removeListener(this); } atoms = new IAtom[growArraySize]; atomCount = 0; notifyChanged(); }
@Test public void testAliphaticSymbols() { for (Elements e : Elements.values()) { int len = e.symbol().length(); if (len == 1 || len == 2) { String smarts = "[" + e.symbol() + "]"; QueryAtomContainer mol = new QueryAtomContainer(null); assertTrue(smarts, Smarts.parse(mol, smarts)); Expr expr = getAtomExpr(mol.getAtom(0)); assertThat(expr, anyOf(is(new Expr(ELEMENT, e.number())), is(new Expr(ALIPHATIC_ELEMENT, e.number())))); } } }
@Test public void bondStereoCisUnspec() { QueryAtomContainer mol = new QueryAtomContainer(null); assertTrue(Smarts.parse(mol, "C/C=C\\?C")); assertThat(Smarts.generate(mol), is("C/C=C\\?C")); // not trans same as cis/unspec mol.removeAllElements(); assertTrue(Smarts.parse(mol, "C/C=C!/C")); assertThat(Smarts.generate(mol), is("C/C=C\\?C")); }
private TIntIntHashMap makeMapping() { final TIntIntHashMap mapping = new TIntIntHashMap(); for (int k=0; k < query.getAtomCount(); ++k) { final IQueryAtom atom = (IQueryAtom) query.getAtom(k); if (atom instanceof LogicalOperatorAtom) { LogicalOperatorAtom log = (LogicalOperatorAtom)atom; String op = log.getOperator(); if (op.equals("and")) { if (log.getRight() instanceof LogicalOperatorAtom) { IQueryAtom iq = ((LogicalOperatorAtom) log.getRight()).getLeft(); if (iq instanceof AtomicNumberAtom) { mapping.put(k, ((AtomicNumberAtom) iq).getAtomicNumber()-200); } } } } } return mapping; }
optset.addAll(Arrays.asList(opts)); QueryAtomContainer query = new QueryAtomContainer(mol.getBuilder()); Map<IChemObject, IChemObject> mapping = new HashMap<>(); Map<IChemObject, IStereoElement> stereos = new HashMap<>(); query.addAtom(qatom); query.addBond(qbond); query.addStereoElement(se.map(mapping));
/** * Returns the atom at the last position in the container. * *@return The atom at the last position */ @Override public IAtom getLastAtom() { return getAtomCount() > 0 ? (IAtom) atoms[getAtomCount() - 1] : null; }
@Test public void atomStereoReordered() { QueryAtomContainer mol = new QueryAtomContainer(null); assertTrue(Smarts.parse(mol, "C[C@H](O)CC")); IBond[] bonds = AtomContainerManipulator.getBondArray(mol); swap(bonds, 1, 2); mol.setBonds(bonds); assertThat(Smarts.generate(mol), is("C[C@@H1](CC)O")); }
.getBuilder())); Iterator bonds = aminoAcid.bonds().iterator(); IAtom bondAtom0 = null; IAtom bondAtom1 = null; || (bondAtom0.getSymbol().equals("N") && bondAtom1.getSymbol().equals("C")) && bond.getOrder() == IBond.Order.SINGLE) { aminoAcid.removeBond(bondAtom0, bondAtom1); QueryBond qbond = new QueryBond(bondAtom0, bondAtom1, Expr.Type.SINGLE_OR_AROMATIC); aminoAcid.addBond(qbond); break;
int position = getAtomNumber(atom); if (position != -1) { for (int i = 0; i < bondCount; i++) { if (bonds[i].contains(atom)) { removeBond(i); --i; removeLonePair(i); --i; removeSingleElectron(i); --i; removeAtomOnly(position); notifyChanged();
if (atomContainer instanceof QueryAtomContainer) { for (int f = 0; f < atomContainer.getAtomCount(); f++) { if (!contains(atomContainer.getAtom(f))) { addAtom(atomContainer.getAtom(f)); if (!contains(atomContainer.getBond(f))) { addBond(atomContainer.getBond(f)); if (!contains(atomContainer.getLonePair(f))) { addLonePair(atomContainer.getLonePair(f)); if (!contains(atomContainer.getSingleElectron(f))) { addSingleElectron(atomContainer.getSingleElectron(f)); notifyChanged(); } else { throw new IllegalArgumentException("AtomContainer is not of type QueryAtomContainer");
if (idx >= atomCount) throw new IndexOutOfBoundsException("No atom at index: " + idx); int aidx = indexOf(atom); if (aidx >= 0) throw new IllegalArgumentException("Atom already in container at index: " + idx); for (IBond bond : bonds()) { for (int i = 0; i < bond.getAtomCount(); i++) { if (oldAtom.equals(bond.getAtom(i))) { for (ISingleElectron ec : singleElectrons()) { if (oldAtom.equals(ec.getAtom())) ec.setAtom(atom); for (ILonePair lp : lonePairs()) { if (oldAtom.equals(lp.getAtom())) lp.setAtom(atom); for (IStereoElement se : stereoElements()) { if (se.contains(oldAtom)) { if (oldStereo == null) { notifyChanged();
@Override public void remove() { if (pointer <= bondCount) removeBond(--pointer); else if (pointer <= bondCount + lonePairCount) removeLonePair((--pointer) - bondCount); else if (pointer <= bondCount + lonePairCount + singleElectronCount) removeSingleElectron((--pointer) - bondCount - lonePairCount); }