Unregisters the ParallaxImageView's SensorManager. Should be called in onPause from
an Activity or Fragment to avoid continuing sensor usage.

@param resetTranslation if the image translation should be reset to the origin
163365
public void unregisterSensorManager(boolean resetTranslation) {
        if (mSensorManager == null || mSensorInterpreter == null) return;

        mSensorManager.unregisterListener(this);
        mSensorManager = null;
        mSensorInterpreter.reset();

        if (resetTranslation) {
            setTranslate(0, 0);
        }
    }
307621
public void reset() {
		for (int i = 0; i < 4; i++) {
			ppCorner.get(i).set(0,0);
			ppDown.get(i).set(0,0);
			ppRight.get(i).set(0,0);
		}
		this.threshCorner = 0;
		this.threshDown = 0;
		this.threshRight = 0;
		version = -1;
		error = L;
		mask = QrCodeMaskPattern.M111;
		alignment.reset();
		mode = Mode.UNKNOWN;
		failureCause = Failure.NONE;
		rawbits = null;
		corrected = null;
		message = null;
	}
151715
boolean cleanupLocalisations() throws SIResourceException
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "cleanupLocalisations");

        // true if all localisations have been cleaned up successfully
        boolean allCleanedUp = true;

        // True if we determine calling reallocation is appropriate
        boolean reallocationCanBeCalled = false;

        //Check the destination has not already been deleted first
        if (!isDeleted())
        {
            synchronized (this) //Stop cleanup happening while the destination is being altered
            {
                //synchronizes with updateLocalisationSet
                //If the entire destination is to be deleted
                //then all the localisations are to be deleted.
                // 448943 Remove a check for !isReconciled - We dont need this
                if (isToBeDeleted())
                {
                    addAllLocalisationsForCleanUp();
                }

                allCleanedUp = _protoRealization.cleanupPremediatedItemStreams();

                if (!isPubSub())
                {
                    //If the entire destination is being deleted, clean up the remote get
                    //infrastructure
                    if (isToBeDeleted())
                    {
                        boolean remoteGetCleanup = _ptoPRealization.cleanupLocalisations();
                        if (allCleanedUp)
                            allCleanedUp = remoteGetCleanup;
                    }
                    else
                    {
                        // PK57432 We are not deleting the destination. Just perform
                        // any other localisation cleanup
                        reallocationCanBeCalled = true;
                    }
                }
                else
                {
                    // For pub/sub, we'll want to remove any infrastructure associated with
                    // durable subscriptions since these are implemented as queue-like localizations.
                    if (isToBeDeleted())
                    {
                        boolean pubSubCleanedUp = _pubSubRealization.cleanupLocalisations();
                        if (allCleanedUp)
                            allCleanedUp = pubSubCleanedUp;
                    }
                    else
                    {
                        // We are not deleting the destination. Just perform
                        // any other localisation cleanup
                        reallocationCanBeCalled = true;
                    }
                }

            }
        }

        // PK57432 We must not hold any locks when we reallocate.
        if (reallocationCanBeCalled)
        {
            boolean syncReallocRequiredCheck;
            synchronized (this) {
                syncReallocRequiredCheck = _isToBeReallocated;
                _isToBeReallocated = false;
            }
            if (syncReallocRequiredCheck)
                reallocateTransmissionStreams(null);
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "cleanupLocalisations", Boolean.valueOf(allCleanedUp));

        return allCleanedUp;
    }
30231
public void reset() {
      excludes = EMPTY_EXCLUDES;
      ignoreDefaultExcludes = false;
      ignoreTransientFields = false;
      ignorePublicFields = true;
      javascriptCompliant = false;
      javaIdentifierTransformer = DEFAULT_JAVA_IDENTIFIER_TRANSFORMER;
      cycleDetectionStrategy = DEFAULT_CYCLE_DETECTION_STRATEGY;
      skipJavaIdentifierTransformationInMapKeys = false;
      triggerEvents = false;
      handleJettisonEmptyElement = false;
      handleJettisonSingleElementArray = false;
      arrayMode = MODE_LIST;
      rootClass = null;
      classMap = null;
      keyMap.clear();
      typeMap.clear();
      beanKeyMap.clear();
      beanTypeMap.clear();
      jsonPropertyFilter = null;
      javaPropertyFilter = null;
      jsonBeanProcessorMatcher = DEFAULT_JSON_BEAN_PROCESSOR_MATCHER;
      newBeanInstanceStrategy = DEFAULT_NEW_BEAN_INSTANCE_STRATEGY;
      defaultValueProcessorMatcher = DEFAULT_DEFAULT_VALUE_PROCESSOR_MATCHER;
      defaultValueMap.clear();
      propertySetStrategy = null/* DEFAULT_PROPERTY_SET_STRATEGY */;
      //ignoreJPATransient = false;
      collectionType = DEFAULT_COLLECTION_TYPE;
      enclosedType = null;
      jsonValueProcessorMatcher = DEFAULT_JSON_VALUE_PROCESSOR_MATCHER;
      javaPropertyNameProcessorMap.clear();
      javaPropertyNameProcessorMatcher = DEFAULT_PROPERTY_NAME_PROCESSOR_MATCHER;
      jsonPropertyNameProcessorMap.clear();
      jsonPropertyNameProcessorMatcher = DEFAULT_PROPERTY_NAME_PROCESSOR_MATCHER;
      beanProcessorMap.clear();
      propertyExclusionClassMatcher = DEFAULT_PROPERTY_EXCLUSION_CLASS_MATCHER;
      exclusionMap.clear();
      ignoreFieldAnnotations.clear();
      allowNonStringKeys = false;
   }
656985
public void resetDestination(String destName)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "resetDestination", destName);

        try
        {
            DestinationHandler dh = destinationIndex.findByName(
                                                                destName,
                                                                messageProcessor.getMessagingEngineBus(),
                                                                null);

            checkDestinationHandlerExists(
                                          dh != null,
                                          destName,
                                          messageProcessor.getMessagingEngineBus());

            // Only applicable to BaseDestinationHandlers
            if (dh instanceof BaseDestinationHandler)
            {
                BaseDestinationHandler bdh = (BaseDestinationHandler) dh;

                // Need to ensure that this change is persisted - specifically that the
                // BDH "toBeIgnored" flag is persisted
                LocalTransaction siTran = txManager.createLocalTransaction(true);

                // Drive the object's reset method
                bdh.reset();

                // Change our entry in the appropriate index.
                destinationIndex.reset(dh);

                // Persist the change
                bdh.requestUpdate((Transaction) siTran);

                // commit the transaction
                siTran.commit();

                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                    SibTr.debug(tc, "Have reset destination " + bdh.getName());
            }
            else
            {
                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                    SibTr.debug(tc, "Not a BDH, cannot reset destination " + dh.getName());
            }
        } catch (MessageStoreException e)
        {
            // No FFDC code needed

            SibTr.exception(tc, e);

            //throw e;
        } catch (SIException e)
        {
            // No FFDC code needed

            SibTr.exception(tc, e);

            //handleRollback(siTran);
            //        throw e;
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "resetDestination");
    }
1065485
public static void unRegister(Monitor monitor) {
        ScheduledFuture future = register.remove(monitor);
        if (future != null) {
            future.cancel(true);// 打断
        }
    }
1207616
void unregisterEventBuses() {
        if (eventsRegistered) {
            eventBusV.unregister(androidComponent);
            eventsRegistered = false;
            logger.trace("-Event2V bus unregistered for view - '{}' and its controllers.",
                    androidComponent.getClass().getSimpleName());
            Mvc.graph().release(this);
        } else {
            logger.trace("!Event2V bus already unregistered for view - '{}'.",
                    androidComponent.getClass().getSimpleName());
        }
    }
1234881
public function resetForLocaleTranslatables(LocaleEntity $locale, $translatables)
    {
        $this->resetForLocale($locale);
        $translatableIDs = [];
        if ($translatables) {
            if ($translatables instanceof TranslatableEntity) {
                $translatableIDs[] = $translatables->getID();
            } elseif (is_int($translatables)) {
                $translatableIDs[] = $translatables;
            } elseif (is_array($translatables)) {
                foreach ($translatables as $translatable) {
                    if ($translatable instanceof TranslatableEntity) {
                        $translatableIDs[] = $translatable->getID();
                    } elseif (is_int($translatable)) {
                        $translatableIDs[] = $translatable;
                    } else {
                        throw new UserMessageException(t('Invalid translatable string specified'));
                    }
                }
            }
        }
        if (empty($translatableIDs)) {
            throw new UserMessageException(t('Invalid translatable string specified'));
        }
        $this->getEntityManager()->getConnection()->executeQuery(
            '
                delete s.*
                from CommunityTranslationStats as s
                inner join CommunityTranslationTranslatablePlaces as p on s.packageVersion = p.packageVersion
                where s.locale = ?
                and (p.translatable = ' . implode(' or p.translatable = ', $translatableIDs) . ')
            ',
            [$locale->getID()]
        );
    }
197919
protected void unsetKeyringMonitorRegistration() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
            Tr.event(this, tc, "unsetKeyringMonitorRegistration");
        }
        if (keyringMonitorRegistration != null) {
            keyringMonitorRegistration.unregister();
            keyringMonitorRegistration = null;
        }
    }
99323
public void reset() {
		if( stitchedImage != null )
			GImageMiscOps.fill(stitchedImage, 0);
		motion.reset();
		worldToCurr.reset();
		first = true;
	}
1063603
@Trivial
    public void unsetSslSupport(ServiceReference<ChannelFactoryProvider> ref) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
            Tr.entry(this, tc, "unsetSslSupport", new Object[] { ref.getProperty("type"), ref });
        }
        // see if its for the same service ref, if yes then destroy
        if (_sslFactoryProvider.getReference() == ref)
        {
            if (_isSSLChain) {
                if (_isChainStarted)
                    performAction(destroyChainAction);
            }

        }
        if (_sslFactoryProvider.unsetReference(ref)) {
            _isSSLEnabled = false;
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.exit(tc, "unsetSslSupport", _isSSLEnabled);
        }

    }
379603
public void clear() {

        if (m_handlerRegistration != null) {
            m_handlerRegistration.removeHandler();
            m_handlerRegistration = null;
        }
        m_changeListeners.clear();
        m_scopeValues.clear();
        m_observerdEntity = null;
    }
869592
private void resetDefaultLocaleMapping(TomcatEmbeddedContext context) {
		context.addLocaleEncodingMappingParameter(Locale.ENGLISH.toString(),
				DEFAULT_CHARSET.displayName());
		context.addLocaleEncodingMappingParameter(Locale.FRENCH.toString(),
				DEFAULT_CHARSET.displayName());
	}
244620
@Override
    public boolean unregisterMonitor(Object annotatedObject) {
        // Clear the listener data
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(this, tc, "unregisteringMonitor =  " + annotatedObject);
        }
        Set<ProbeListener> listeners = removeListenersForMonitor(annotatedObject);
        if (listeners == null) {
            return false;
        }

        // Remove the listeners associated with the inactive monitor and
        // find out which classes need to be transformed to remove stale probes
        Collection<Class<?>> effectedClasses = processRemovedListeners(listeners);

        // Update the classes to remove dead probes (optional)
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(this, tc, "effectedClasses.size() =  " + effectedClasses.size());
        }
        this.transformer.instrumentWithProbes(effectedClasses);
        Set set = moduleInstanceToBundleMap.entrySet();
        Iterator i = set.iterator();
        while (i.hasNext()) {
            Map.Entry mapE = (Map.Entry) i.next();
            if (mapE != null && mapE.getValue().equals(annotatedObject.getClass().getName())) {
                PmiAbstractModule s = (PmiAbstractModule) mapE.getKey();
                s.unregister();
            }
        }
        return true;
    }
248494
void deleteCurrentLocale() {

        // there has to remain at least one content locale
        if (m_contentLocales.size() > 1) {
            String deletedLocale = m_locale;
            m_contentLocales.remove(deletedLocale);
            m_registeredEntities.remove(m_entityId);
            m_changedEntityIds.remove(m_entityId);
            m_deletedEntities.add(m_entityId);
            getValidationHandler().getValidationContext().removeEntityId(m_entityId);
            unregistereEntity(m_entityId);
            enableSave();
            String nextLocale = null;
            if (m_registeredEntities.isEmpty()) {
                nextLocale = m_contentLocales.iterator().next();
            } else {
                nextLocale = CmsContentDefinition.getLocaleFromId(m_registeredEntities.iterator().next());
            }
            switchLocale(nextLocale);
        }
    }
161891
public void clearLocalisingUuidsSet()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "clearLocalisingUuidsSet");

    if (_queuePointsGuessSet != null)
    {
      synchronized (_queuePointsGuessSet)
      {
        _queuePointsGuessSet.clear();
      }
    }

    if (_remoteQueuePointsGuessSet != null)
    {
      synchronized (_remoteQueuePointsGuessSet)
      {
        _remoteQueuePointsGuessSet.clear();
      }
    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "clearLocalisingUuidsSet");
    return;
  }
381534
public final void unregisterView(final View view) {
        mActivity.runOnUiThread(new Runnable() {
            @Override
            public void run() {
                if (null != mRenderableViewGroup && view.getParent() == mRenderableViewGroup) {
                    mRenderableViewGroup.removeView(view);
                }
            }
        });
    }