UnmanagedLXC Destructor.

        It requires force to be true in order to work. Otherwise it throws an
        error.
190101
def destroy(self, force=False):
        
        if force:
            super(UnmanagedLXC, self).destroy()
        else:
            raise UnmanagedLXCError('Destroying an unmanaged LXC might not '
                'work. To continue please call this method with force=True')
630206
@Unbind
    public void unbindFactory(Factory factory) {
        try {
            lock.lock();
            InstanceDeclaration declaration = getDeclarationByFactory(factory);
            if (declaration != null) {
                LOGGER.info("Disposing instance created by");
                declaration.dispose();
                declarations.remove(declaration);
            }
        } finally {
            lock.unlock();
        }
    }
897740
public function unload()
    {
        if (null === $this->state) {
            throw new NotLoadedException('The type descriptor is not loaded.');
        }

        $this->containingModule = null;
        $this->state = null;
    }
35030
function()
	{
		this._destroyBinding();

		if(this._collectionBinder) this._collectionBinder.destroyBoundViews();

		this._modelBindersMap = null;
		this._collectionBinder = null;
		this._bindingIndex = null;
		this._itemAlias = null;

		this.element.removeAttribute(settings.DATA_RENDERED_ATTR);
		this.undelegateEvents();
		this.destroySubviews();
		if(this.dispatcher)
		{
			this.dispatcher.off('refresh', this.f('refreshAll'));
			this.dispatcher.off('refreshFromRoot', this.f('refreshFromRoot'));
			this.dispatcher.off('refreshRaf', this.f('requestRefreshAll'));
			this.dispatcher.off('refreshFromRootRaf', this.f('requestRefreshAllFromRoot'));
			this.dispatcher.off('dispatcher:noaction', this.f('_dispatchNoAction'));
		}

		if(this.destroy !== noop) this.destroy();
		if(typeof this.afterDestroy === 'function') this.afterDestroy();

		this._subviewsStruct = null;
		this._explicitSubviewsStruct = null;
		this.subviews = null;
		this._isRunning = false;
		this._isSuspended = false;
	}
1115382
public Object unbindName(String name, IndexedList<String> symbolTable) {
    if (!symbolTable.contains(name)) {
      return null;
    }
    int index = symbolTable.getIndex(name);
    return bindings.remove(index);
  }
168435
@Override
    protected <T> void checkUnbound(LifecycleManager manager) throws StoreHasAssociatedObjectsException {
        Tracking tracking = TRACK.get(manager);
        if (tracking != null) {
            if (!tracking.isEmpty()) {
                throw new StoreHasAssociatedObjectsException();
            }
            TRACK.remove(manager);
        }
    }
850157
protected synchronized void doClose()
    {
        try
        {
            LockManager lm = getImplementation().getLockManager();
            Enumeration en = objectEnvelopeTable.elements();
            while (en.hasMoreElements())
            {
                ObjectEnvelope oe = (ObjectEnvelope) en.nextElement();
                lm.releaseLock(this, oe.getIdentity(), oe.getObject());
            }

            //remove locks for objects which haven't been materialized yet
            for (Iterator it = unmaterializedLocks.iterator(); it.hasNext();)
            {
                lm.releaseLock(this, it.next());
            }

            // this tx is no longer interested in materialization callbacks
            unRegisterFromAllIndirectionHandlers();
            unRegisterFromAllCollectionProxies();
        }
        finally
        {
            /**
             * MBAIRD: Be nice and close the table to release all refs
             */
            if (log.isDebugEnabled())
                log.debug("Close Transaction and release current PB " + broker + " on tx " + this);
            // remove current thread from LocalTxManager
            // to avoid problems for succeeding calls of the same thread
            implementation.getTxManager().deregisterTx(this);
            // now cleanup and prepare for reuse
            refresh();
        }
    }
779233
public void forceClose() {
        // Move all elements from usedInstances to unusedInstances in a threadsafe way
        for (final T usedInstance : new ArrayList<>(usedInstances)) {
            if (usedInstances.remove(usedInstance)) {
                unusedInstances.add(usedInstance);
            }
        }
        close();
    }
696925
@Override
    public void aborted(DataBinder parameters, Throwable throwable) {
        try { first.aborted(parameters, throwable);  } catch (Throwable t) {}
        try { second.aborted(parameters, throwable); } catch (Throwable t) {}
    }
31209
private void destroyInitializer() {
        GdxMaps.clearAll(fieldProcessors, methodProcessors, typeProcessors);
        GdxArrays.clearAll(scannedMetaAnnotations, scannedAnnotations, processors, delayedConstructions,
                manuallyAddedComponents, manuallyAddedProcessors);
    }
486617
@MainThread
    private void handleUnRegistration(Object targetObj) {
        if (targetObj == null) {
            throw new NullPointerException("Target cannot be null");
        }

        EventTarget target = null;

        for (Iterator<EventTarget> iterator = targets.iterator(); iterator.hasNext(); ) {
            EventTarget listTarget = iterator.next();
            if (listTarget.targetObj == targetObj) {
                iterator.remove();
                target = listTarget;
                target.targetObj = null;
                break;
            }
        }

        if (target == null) {
            Utils.logE(targetObj, "Was not registered");
        }

        Utils.log(targetObj, "Unregistered");
    }
814221
function Destructible () {
    var vargs = []
    vargs.push.apply(vargs, arguments)

    // By default, we wait a full second for all outstanding callbacks to
    // return.
    this._timeout = typeof vargs[0] == 'number' ? vargs.shift() : 1000

    // Displayed when we timeout.
    this.key = coalesce(vargs.shift())

    this.context = vargs

    // Errors returned to callbacks.
    this._errors = []

    // Set immediately upon destruction. Will be true if inspected by any of the
    // destructors registered with `destruct` or `scrammed`.
    this.destroyed = false

    // You're welcome to dump this list of waiting callbacks if it helps you
    // with debugging.
    this.waiting = []

    // Listen to know when we're done.
    this.completed = new Signal

    // Listen to know when to shut down.
    this.destruct = new Signal

    // Listen to know if we've forcibly shutdown before all callbacks have
    // returned.
    this.scrammed = new Signal

    this.children = new Cubbyhole
    this.siblings = new Cubbyhole

    this._completed = new Signal

    this.instance = INSTANCE = Monotonic.increment(INSTANCE, 0)
    this._destroyedAt = null
    this._index = 0
    this._vargs = []

    this._errored = function () {}

}
757468
def destroy(self, force=False):
        
        if self.persisted:
            if self.soft_delete and not force:
                self.__class__.update(
                    values={
                        self.__class__.deleted_at_column(): datetime.utcnow()
                        },
                    where=self.where_self
                    )
            else:
                self.__class__.delete(
                    where=self.where_self,
                    skip_soft_delete=True
                    )
        else:
            raise RecordNotPersisted("Record's primary key is None")
334496
public static void throwNotationException(NotationDeclaration oldDecl, NotationDeclaration newDecl)
        throws XMLStreamException
    {
        throw new WstxParsingException
            (MessageFormat.format(ErrorConsts.ERR_DTD_NOTATION_REDEFD,
                                  new Object[] {
                                  newDecl.getName(),
                                  oldDecl.getLocation().toString()}),
             newDecl.getLocation());
    }
778241
function()
	{
		if(this._collectionBinder)
		{
			this._collectionBinder.destroyBoundViews();
		}
		else
		{
			var subView, i, l;

			// Destroy subviews
			if(this.subviews !== null)
			{
				for(i = 0, l = this.subviews.length; i < l; i++)
				{
					subView = this.subviews[i];
					subView.destroyAll();
				}
			}
			this.subviews = null;
			this._subviewsStruct = null;
		}
	}
905930
def _unwrap(x, deserializeFunc, decodeFunc=base64.urlsafe_b64decode, compress=True):
    
    return deserializeFunc(decodeFunc(x), compress)
1219214
private final void _declareNotReleasable() throws SevereMessageStoreException
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "_declareNotReleasable");

        if (_isStorageManaged)
        {
            _itemCache.unmanage(this);
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "_declareNotReleasable");
    }