Resets exporter to null. Used only for unit tests.
162447
@VisibleForTesting
  static void unsafeResetExporter() {
    synchronized (monitor) {
      if (instance != null) {
        instance.intervalMetricReader.stop();
      }
      instance = null;
    }
  }
1048357
public void export() {
        logger.info("----------------------------"); //$NON-NLS-1$
        logger.info(Messages.i18n.format("StorageExporter.StartingExport")); //$NON-NLS-1$
        try {
            storage.beginTx();
            try {
                exportMetadata();
                exportUsers();
                exportGateways();
                exportPlugins();
                exportRoles();
                exportPolicyDefs();

                exportOrgs();
            } finally {
                storage.rollbackTx();
                try { writer.close(); } catch (Exception e) { }
            }
            logger.info(Messages.i18n.format("StorageExporter.ExportComplete")); //$NON-NLS-1$
            logger.info("------------------------------------------"); //$NON-NLS-1$
        } catch (StorageException e) {
            throw new RuntimeException(e);
        }
    }
1002110
public void reset() {
        methodMap.clear();
        postBindMap.clear();
        postUnBindMap.clear();
        cellInitedMap.clear();
        cellFlareIdMap.clear();
        mvResolver.reset();
    }
957082
private void nullConvert(Label end) {
        LocalVariable temp = createLocalVariable("temp", TypeDesc.OBJECT);
        storeLocal(temp);
        loadLocal(temp);
        Label notNull = createLabel();
        ifNullBranch(notNull, false);
        loadNull();
        branch(end);
        notNull.setLocation();
        loadLocal(temp);
    }
799117
public void clear() {
        this.variables.clear();
        this.methods.clear();
        this.importedClasses.clear();
        this.importedPackages.clear();
        this.importedCommands.clear();
        this.importedObjects.clear();
        if (this.parent == null)
            this.loadDefaultImports();
        this.classCache.clear();
        this.names.clear();
    }
629166
public void resets()
    {
        if (TraceComponent.isAnyTracingEnabled()&&logger.isLoggable (Level.FINE)) {  //306998.15
            logger.logp(Level.FINE, CLASS_NAME,"resets", "resets");
        } 
        this.in = null;
    }
730167
public void reset() {

		this.jawrConfigMgrObjectName = null;
		this.debugOverriden = false;
		this.bundleProcessingAtBuildTime = false;
		this.requestURL = null;
		this.stopWatch = null;
		this.interruptProcessingBundle.set(false);
	}
404
public void reset()
    {
        try{
            out=IO.getNullWriter();
            super.flush();
            out=new OutputStreamWriter(os,encoding);
            written=false;
        }
        catch(UnsupportedEncodingException e)
        {
            log.fatal(e); System.exit(1);
        }
    }
1051076
public void reset()
    {
        if (mNsCount > 0) {
            mNamespaceBuilder.reset();
            mDefaultNsDeclared = false;
            mNsCount = 0;
        }

        /* No need to clear attr name, or NS prefix Strings; they are
         * canonicalized and will be referenced by symbol table in any
         * case... so we can save trouble of cleaning them up. This Object
         * will get GC'ed soon enough, after parser itself gets disposed of.
         */
        if (mAttrCount > 0) {
            mValueBuilder.reset();
            mAttrCount = 0;
            if (mXmlIdAttrIndex >= 0) {
                mXmlIdAttrIndex = XMLID_IX_NONE;
            }
        }
        /* Note: attribute values will be cleared later on, when validating
         * namespaces. This so that we know how much to clean up; and
         * occasionally can also just avoid clean up (when resizing)
         */
    }
149406
function reset(method, key) {
    if (exports.results.has(method)) {
        if (key)
            return exports.results.get(method).del(key);
        else
            return exports.results.get(method).reset();
    }
}
491542
protected void doExport() {
        // Get archive
        final Archive<?> archive = getArchive();
        if (log.isLoggable(Level.FINE)) {
            log.fine("Exporting archive - " + archive.getName());
        }

        // Obtain the root
        final Node rootNode = archive.get(ArchivePaths.root());

        // Recursively process the root children
        for (Node child : rootNode.getChildren()) {
            processNode(child);
        }
    }
445233
public void resetWithEmptyString()
    {
        mInputBuffer = null;
        mInputStart = -1; // indicates shared buffer not used
        mInputLen = 0;
        mResultString = "";
        mResultArray = null;
        if (mHasSegments) {
            clearSegments();
        }
        mCurrentSize = 0;
    }
1201371
private void reset() {
		// Reset codecs
		resetFormats();
		
		// Reset channels
		if (this.rtcpMux) {
			this.rtcpMux = false;
		}

		// Reset ICE
		if (this.ice) {
			disableICE();
		}

		// Reset WebRTC
		if (this.dtls) {
			disableDTLS();
		}
		
		// Reset statistics
		this.statistics.reset();
		this.cname = "";
		this.ssrc = 0L;
	}
773660
@Unbind(id = "exporterServices")
    void unbindExporterService(ServiceReference<ExporterService> serviceReference) {
        LOG.debug(linkerName + " : Unbind the ExporterService " + exportersManager.getDeclarationBinder(serviceReference));
        synchronized (lock) {
            exportersManager.removeLinks(serviceReference);
            exportersManager.remove(serviceReference);
        }
    }
506954
public static Instrumentation initAgentAtRuntimeAndReportSuccess() {
        try {
            setSystemClassLoaderClassPath();
        } catch (Exception e) {
            Log.e("Could not set classpath. Tool will be off.", e);
            return null;
        }
        try {
            return addClassfileTransformer();
        } catch (Exception e) {
            Log.e("Could not add transformer. Tool will be off.", e);
            return null;
        }
    }
71378
public void reset() {
        firstPointer = null;
        nextLoadPointer = null;
        nextUnloadPointer = null;
        firstCutpointPointer = null;
        mode = MODE_NORMAL;
    }
837924
public void reset ()
  {
    resetBuffer ();
    m_aCharacterEncoding = null;
    m_nContentLength = 0;
    m_sContentType = null;
    m_aLocale = null;
    m_aCookies.clear ();
    m_aHeaders.clear ();
    m_nStatus = HttpServletResponse.SC_OK;
    m_sErrorMessage = null;
  }