destroys the current dataLogger
338848
@Override
    public void destroy() {
    	 if (dataRecorderLifycycleListner != null) {
         this.dataRecorderLifycycleListner.recorderDataRecorderClosed(this);
         }
        try {
            this.dataLogger.destroy();
        } catch (IOException e) {
            throw new DelegatedRuntimeException(e);
        }
    }
16217
async def destroy(self):
        """"""

        self.logger.debug("destroy command")
        self.state = 'destroyed'

        await self.set_topic("")
        self.nowplayinglog.debug("---")
        self.nowplayingauthorlog.debug("---")
        self.nowplayingsourcelog.debug("---")
        self.timelog.debug(_timebar.make_timebar())
        self.prev_time = "---"
        self.statuslog.debug("Destroying")

        self.mready = False
        self.vready = False
        self.pause_time = None
        self.loop_type = 'off'

        if self.vclient:
            try:
                await self.vclient.disconnect()
            except Exception as e:
                logger.error(e)
                pass

        if self.streamer:
            try:
                self.streamer.stop()
            except:
                pass

        self.vclient = None
        self.vchannel = None
        self.streamer = None
        self.current_duration = 0
        self.current_download_elapsed = 0
        self.is_live = False
        self.queue = []
        self.prev_queue = []

        if self.embed:
            await self.embed.delete()
            self.embed = None

        self.clear_cache()
933514
protected void destroy() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "Destroying these headers: " + this);
        }
        // if we have headers present, or reference parse buffers (i.e.
        // the first header parsed threw an error perhaps), then clear
        // the message now
        if (null != this.hdrSequence || HeaderStorage.NOTSET != this.parseIndex) {
            clear();
        }
        this.byteCacheSize = DEFAULT_CACHESIZE;
        this.incomingBufferSize = DEFAULT_BUFFERSIZE;
        this.outgoingHdrBufferSize = DEFAULT_BUFFERSIZE;
        this.useDirectBuffer = true;
        this.limitNumHeaders = DEFAULT_LIMIT_NUMHEADERS;
        this.limitTokenSize = DEFAULT_LIMIT_TOKENSIZE;
        this.headerChangeLimit = HeaderStorage.NOTSET;
    }
1090039
function clearLog() : void
    {
        @unlink($this -> errLogger -> getFile());
        @unlink($this -> logger -> getFile());
        @unlink($this -> errLogger -> getFile().'.shell');
        @unlink($this -> logger -> getFile().'.shell');
    }
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")
1298638
public void destroy() {

        m_attributeName = null;
        m_attributeType = null;
        m_attributeValueViews.clear();
        m_attributeValueViews = null;
        m_dndHandler = null;
        m_entity = null;
        m_entityType = null;
        m_entityBackEnd = null;
        m_widgetService = null;
    }
340131
def destroy(self):
        """"""
        if self.id is not None and self._mumps_c is not None:
            self.id.job = -2 # JOB_END
            self._mumps_c(self.id)
        self.id = None
        self._refs = None
134214
public void destroy() {

        m_currentFocus = null;
        if (m_handlerRegistration != null) {
            m_handlerRegistration.removeHandler();
        }
        m_handlerRegistration = null;
        clearInstance();
    }
1069054
public static void destroyDataSources(){
		synchronized (dataSourcesStructureLock){
			for (Map.Entry<String, DataSource> dsEntry: dataSources.entrySet()){
				String dsName = dsEntry.getKey();
				DataSource ds = dsEntry.getValue();
				for (Map.Entry<String, DataSourceProvider> dspEntry: dataSourceProviders.entrySet()){		// try them one by one
					String dspName = dspEntry.getKey();
					DataSourceProvider dsp = dspEntry.getValue();
					try{
						if (dsp.destroyDataSource(ds)){
							break;
						}
					}catch(NoClassDefFoundError e){
						// ignore
					}catch(Throwable e){
						log.error("Error when destroying data source '" + dsName + "' using provider '" + dspName + "'", e);
					}
				}
			}
			dataSources.clear();
		}
	}
858830
function() {
				this.abort();

				if (_fr) {
					_fr.getRuntime().exec.call(this, 'FileReader', 'destroy');
					_fr.disconnectRuntime();
				}

				self = _fr = null;
			}
105767
@Override
    public void destroy()
    {
        if (indexManager != null)
        {
            indexManager.close();
        }
        if (schemaManager != null)
        {
            schemaManager.dropSchema();
        }
        schemaManager = null;
        externalProperties = null;

        for (Object connectionPool : hostPools.values())
        {
            if (connectionPool != null && connectionPool.getClass().isAssignableFrom(ConnectionPool.class))
            {
                ((ConnectionPool) connectionPool).close(true);
            }
        }
        ((CassandraRetryService) hostRetryService).shutdown();
    }
289040
def destroy(self):
        
        # if this is the main_app - set the _main_app class variable to `None`.
        if self == App._main_app:
            App._main_app = None
        self.tk.destroy()
22411
function destroy() {
			var act = new NobleMachine(function() {
				if (me.onDestroy) {
					var preact = me.onDestroy();
					if (preact && preact.start instanceof Function) {
						act.toNext(preact)
						return;
					}
				}
			});

			act.next(function() {
				var sql = "DELETE FROM " + model.table
						+ " WHERE `" + model.primary + "` = " + me[model.primary];

				act.toNext(db_query(sql));
			});

			act.next(function() {
				logger.log("Successfully deleted `" + model.ident + "` record `" + me[model.primary] + "`");

				for (var param in me) {
					delete me[param];	
				}
			});

			act.error(function(err) {
				logger.error("Error deleting `" + model.ident + "` record: " + JSON.stringify(err));
				act.emitError(err);
			});

			return act;
		}
990904
def destroy(self):
        
        if self.library:
            return self.library.Par_Destroy(ctypes.byref(self.pointer))
80903
@Override
  public void destroy()
  {
    Thread thread = Thread.currentThread();
    ClassLoader oldLoader = thread.getContextClassLoader();
    
    try {
      thread.setContextClassLoader(this);
      
      WeakStopListener stopListener = _stopListener;
      _stopListener = null;

      super.destroy();
      
      thread.setContextClassLoader(oldLoader);

      ClassLoader parent = getParent();
      for (; parent != null; parent = parent.getParent()) {
        if (parent instanceof EnvironmentClassLoader) {
          EnvironmentClassLoader loader = (EnvironmentClassLoader) parent;

          loader.removeListener(stopListener);
        }
      }
    } finally {
      thread.setContextClassLoader(oldLoader);
      
      //_owner = null;
      _attributes = null;
      _listeners = null;
      //_scanListeners = null;
      //_stopListener = null;

      /*
      EnvironmentAdmin admin = _admin;
      _admin = null;

      if (admin != null)
        admin.unregister();
        */
    }
  }
444304
@Override
    public void destroy() {
        try {
            super.destroy();
        } finally {
            if (myOwnJdbcHelper && defaultJdbcHelper != null
                    && defaultJdbcHelper instanceof AbstractJdbcHelper) {
                try {
                    ((AbstractJdbcHelper) defaultJdbcHelper).destroy();
                } catch (Exception e) {
                    LOGGER.warn(e.getMessage(), e);
                } finally {
                    defaultJdbcHelper = null;
                }
            }
        }
    }
674621
private void destroySession() {
        currentSessionId = 0;
        setAppLaunchPushed(false);
        getConfigLogger().verbose(getAccountId(),"Session destroyed; Session ID is now 0");
        clearSource();
        clearMedium();
        clearCampaign();
        clearWzrkParams();
    }