removes a given attachment from molecule

@param toRemove a atom to be removed
@throws CTKException general ChemToolKit exception passed to HELMToolKit
496473
public void removeAttachment(IAtomBase toRemove) throws CTKException {

    Map<String, IAtomBase> groups = getRgroups();
    for (String key : groups.keySet()) {

      if (groups.get(key).compare(toRemove)) {
        for (int i = 0; i < attachments.size(); i++) {
          if (attachments.get(i).getLabel().equals(key)) {
            attachments.remove(i);
            break;
          }
        }
      }
    }
  }
1225506
public void removeImageFromImageAttachmentBand(final int position) {
		images.remove(position);
		attachments.setupLayoutListener();
		setAttachButtonState();
		if (images.size() == 0) {
			// Hide attachment band after last attachment is removed
			attachments.setVisibility(View.GONE);
			return;
		}
		addAdditionalAttachItem();
	}
212937
public static <MK> void removeAtomicMap(Cache<MK, ?> cache, MK key) {
      // This removes any entry from the cache but includes special handling for fine-grained maps
      FineGrainedAtomicMapProxyImpl.removeMap((Cache<Object, Object>) cache, key);
   }
95556
function(elem) {
			elem = $(elem);
			if (!elem.hasClass(this._getMarker())) {
				return;
			}
			this._preDestroy(elem, this._getInst(elem));
			elem.removeData(this.name).removeClass(this._getMarker());
		}
308239
public void removeAttribute(String name) {
        if (getAttributes() != null) {
            List<Attribute> toRemove = new ArrayList<Attribute>();
            for (Attribute attr : getAttributes()) {
                if (attr.getAttributeName().equals(name))
                    toRemove.add(attr);
            }
            for (Attribute attr : toRemove)
                getAttributes().remove(attr);
        }
    }
127090
public void removeTaggedComponent(final String tag) {
		TemplateModel model = getOrCreateComponentModel();
		if (model.taggedComponents != null) {
			WComponent component = model.taggedComponents.remove(tag);
			if (model.taggedComponents.isEmpty()) {
				model.taggedComponents = null;
			}
			if (component != null) {
				remove(component);
			}
		}
	}
781278
public synchronized void remove(E key)
    {    
        Entry<E, T> entry = map.get(key);
        this.tail.prev = entry.prev;
        entry.prev.next = this.tail;
        map.remove(entry.key);
        this.length--;   
    }
46372
def delete(self):
        """"""
        # Delete the Helm Release
        out = helm(
            "delete",
            self.release,
            "--purge"
        )
        if out.returncode != 0:
            print(out.stderr)
        else:
            print(out.stdout)

        # Delete the Kubernetes namespace
        out = kubectl(
            "delete",
            "namespace",
            self.namespace
        )
        if out.returncode != 0:
            print(out.stderr)
        else:
            print(out.stdout)
158295
@SuppressWarnings("UnusedReturnValue")
    boolean removeBond() {
		final BluetoothDevice device = mGatt.getDevice();
		if (device.getBondState() == BluetoothDevice.BOND_NONE)
			return true;

		mService.sendLogBroadcast(DfuBaseService.LOG_LEVEL_VERBOSE, "Removing bond information...");
		boolean result = false;
		/*
		 * There is a removeBond() method in BluetoothDevice class but for now it's hidden. We will call it using reflections.
		 */
		try {
            //noinspection JavaReflectionMemberAccess
            final Method removeBond = device.getClass().getMethod("removeBond");
            mRequestCompleted = false;
            mService.sendLogBroadcast(DfuBaseService.LOG_LEVEL_DEBUG, "gatt.getDevice().removeBond() (hidden)");
            result = (Boolean) removeBond.invoke(device);

            // We have to wait until device is unbounded
            try {
                synchronized (mLock) {
                    while (!mRequestCompleted && !mAborted)
                        mLock.wait();
                }
            } catch (final InterruptedException e) {
                loge("Sleeping interrupted", e);
            }
		} catch (final Exception e) {
			Log.w(TAG, "An exception occurred while removing bond information", e);
		}
		return result;
	}
773785
public static void remove(final String key) {
        SharedPreferences prefs = getPreferences();
        final Editor editor = prefs.edit();
        if (prefs.contains(key + LENGTH)) {
            // Workaround for pre-HC's lack of StringSets
            int stringSetLength = prefs.getInt(key + LENGTH, -1);
            if (stringSetLength >= 0) {
                editor.remove(key + LENGTH);
                for (int i = 0; i < stringSetLength; i++) {
                    editor.remove(key + "[" + i + "]");
                }
            }
        }
        editor.remove(key);

        editor.apply();
    }
50554
public static void remove(String key) {
        if (setContext()) {
            m_context.remove(key);
        } else {
            m_defaultContext.remove(key);
        }
    }
1007897
function(ctx) {
				var node = ctx.node;
				// FT.debug("nodeRemoveMarkup()", node.toString());
				// TODO: Unlink attr.ftnode to support GC
				if (node.li) {
					$(node.li).remove();
					node.li = null;
				}
				this.nodeRemoveChildMarkup(ctx);
			}
1001979
function unmountComponentFromNode(instance, container, safely) {
	  if (false) {
	    ReactInstrumentation.debugTool.onBeginFlush();
	  }
	  ReactReconciler.unmountComponent(instance, safely);
	  if (false) {
	    ReactInstrumentation.debugTool.onEndFlush();
	  }
	
	  if (container.nodeType === DOC_NODE_TYPE) {
	    container = container.documentElement;
	  }
	
	  // http://jsperf.com/emptying-a-node
	  while (container.lastChild) {
	    container.removeChild(container.lastChild);
	  }
	}
1194697
@Override
    public void removeAtomContainer(int pos) {
        for (int i = pos; i < atomContainerCount - 1; i++) {
            atomContainers[i] = atomContainers[i + 1];
            multipliers[i] = multipliers[i + 1];
        }
        atomContainers[atomContainerCount - 1] = null;
        atomContainerCount--;
    }
1053140
public <T> void remove(ElementDescriptor<T> property)
	{
		if (mRemove == null)
		{
			mRemove = new HashMap<ElementDescriptor<?>, Object>(16);
		}
		mRemove.put(property, null);

		if (mSet != null)
		{
			mSet.remove(property);
		}
	}
995156
private void breakBond(IAtom atom, IAtomContainer molecule) {
        Iterator<IBond> bonds = molecule.bonds().iterator();
        while (bonds.hasNext()) {
            IBond bond = (IBond) bonds.next();
            if (bond.contains(atom)) {
                molecule.removeElectronContainer(bond);
                break;
            }
        }
    }
258336
private void remove(K key, boolean withMissCount) {
		writeLock.lock();
		CacheObj<K, V> co;
		try {
			co = cacheMap.remove(key);
			if (withMissCount) {
				this.missCount--;
			}
		} finally {
			writeLock.unlock();
		}
		if (null != co) {
			onRemove(co.key, co.obj);
		}
	}