Search for and remove initial BaseTransition classes that have
already been applied to this BaseTransition's target element.
330198
function _flush() {
    for ( const prop in _classes ) {
      if ( _classes.hasOwnProperty( prop ) &&
           _classes[prop] !== _classes.BASE_CLASS &&
           _dom.classList.contains( _classes[prop] ) ) {
        _dom.classList.remove( _classes[prop] );
      }
    }
  }
217288
protected function forgetChangedClasses()
    {
        $frozenNamespaces = [];
        /** @var $package Package */
        foreach ($this->packageManager->getAvailablePackages() as $packageKey => $package) {
            if ($this->packageManager->isPackageFrozen($packageKey)) {
                $frozenNamespaces = array_merge($frozenNamespaces, $package->getNamespaces());
            }
        }
        $frozenNamespaces = array_unique($frozenNamespaces);

        $classNames = array_keys($this->classReflectionData);
        foreach ($frozenNamespaces as $namespace) {
            $namespace .= '\\';
            foreach ($classNames as $index => $className) {
                if (strpos($className, $namespace) === 0) {
                    unset($classNames[$index]);
                }
            }
        }

        foreach ($classNames as $className) {
            if (!$this->statusCache->has($this->produceCacheIdentifierFromClassName($className))) {
                $this->forgetClass($className);
            }
        }
    }
295524
private void pruneTracks(SetTrackInfo<Desc> info, GrowQueue_I32 unassociated) {
		if( unassociated.size > maxInactiveTracks ) {
			// make the first N elements the ones which will be dropped
			int numDrop = unassociated.size-maxInactiveTracks;
			for (int i = 0; i < numDrop; i++) {
				int selected = rand.nextInt(unassociated.size-i)+i;
				int a = unassociated.get(i);
				unassociated.data[i] = unassociated.data[selected];
				unassociated.data[selected] = a;
			}
			List<PointTrack> dropList = new ArrayList<>();
			for (int i = 0; i < numDrop; i++) {
				dropList.add( info.tracks.get(unassociated.get(i)) );
			}
			for (int i = 0; i < dropList.size(); i++) {
				dropTrack(dropList.get(i));
			}
		}
	}
683098
function () {
        var cleanup = function () {
            u.off(this.element,'transitionend', cleanup);
            // this.element.removeEventListener('transitionend', cleanup);
            u.off(this.element,'webkitTransitionEnd', cleanup);
            // this.element.removeEventListener('webkitTransitionEnd', cleanup);
            u.removeClass(this.element, 'is-animating');
        }.bind(this);

        // Remove animation class once the transition is done.
        u.on(this.element,'transitionend', cleanup);
        // this.element.addEventListener('transitionend', cleanup);
        u.on(this.element,'webkitTransitionEnd', cleanup);
        // this.element.addEventListener('webkitTransitionEnd', cleanup);
    }
1318046
protected function removeNotImportantRemainingActions()
    {
        // remove remaining 'move' actions
        if (!empty($this->actions[self::GROUP_ADD])) {
            foreach ($this->actions[self::GROUP_ADD] as $index => $action) {
                if ($action[0] === self::MOVE) {
                    unset($this->actions[self::GROUP_ADD][$index]);
                }
            }
        }
        // remove remaining 'remove' actions if there are no any 'add' actions
        if (!empty($this->actions[self::GROUP_REMOVE]) && empty($this->actions[self::GROUP_ADD])) {
            unset($this->actions[self::GROUP_REMOVE]);
        }
    }
1120830
protected void deleteUnmappedActivityInstances(MigratingProcessInstance migratingProcessInstance) {
    Set<MigratingScopeInstance> leafInstances = collectLeafInstances(migratingProcessInstance);
    final DeleteUnmappedInstanceVisitor visitor = new DeleteUnmappedInstanceVisitor(executionBuilder.isSkipCustomListeners(), executionBuilder.isSkipIoMappings());

    for (MigratingScopeInstance leafInstance : leafInstances) {
      MigratingScopeInstanceBottomUpWalker walker = new MigratingScopeInstanceBottomUpWalker(leafInstance);

      walker.addPreVisitor(visitor);

      walker.walkUntil(new ReferenceWalker.WalkCondition<MigratingScopeInstance>() {

        @Override
        public boolean isFulfilled(MigratingScopeInstance element) {
          // walk until top of instance tree is reached or until
          // a node is reached for which we have not yet visited every child
          return element == null || !visitor.hasVisitedAll(element.getChildScopeInstances());
        }
      });
    }
  }
124373
def clean_previous_run(self):
        
        # Execute the base class treatment...
        super(Alignak, self).clean_previous_run()

        # Clean all lists
        self.pollers.clear()
        self.reactionners.clear()
        self.brokers.clear()
309338
synchronized private void clearCachedStructures() {
        mapsInitialized = false;
        packageMap = new HashMap();
        classSource = new HashMap();
        unqNameTable = null;
        nameSpaceChanged();
    }
477560
function removeClass(element, name) {
    var oldList = classList(element),
        newList;

    if (!hasClass(element, name)) return;

    // Replace the class name.
    newList = oldList.replace(' ' + name + ' ', ' ');

    // Trim the opening and closing spaces.
    element.className = newList.substring(1, newList.length - 1);
  }
185227
function(current_templates) {

		var i = 0,
			count = current_templates.length,
			previous_template = null,
			guid;

		for (; i < count; i++) {

			delete this._remove_queue[current_templates[i].guid];
			this._animateInsertion(current_templates[i], previous_template, i, current_templates);
			previous_template = current_templates[i];

		}

		for (guid in this._remove_queue) {

			this._animateRemoval(this._remove_queue[guid]);

		}

		this._remove_queue = {};

	}
396005
def _filter_classes(cls_list, cls_type):
    """"""
    for cls in cls_list:
        if isinstance(cls, type) and issubclass(cls, cls_type):
            if cls_type == TempyPlace and cls._base_place:
                pass
            else:
                yield cls
701176
def stop_class(self, class_):
        ""
        matches = filter(lambda svc: isinstance(svc, class_), self)
        map(self.stop, matches)
993748
function setElement( targetElement ) {
    // If the element has already been set,
    // clear the transition classes from the old element.
    if ( _dom ) {
      remove();
      animateOn();
    }
    _dom = targetElement;
    _dom.classList.add( _classes.BASE_CLASS );
    _transitionEndEvent = _getTransitionEndEvent( _dom );
  }
481290
function removeTargetsFromAnimations(targetsArray, animations) {
  for (let a = animations.length; a--;) {
    if (arrayContains(targetsArray, animations[a].animatable.target)) {
      animations.splice(a, 1);
    }
  }
}
195583
function removeResizeObserver(targetElement) {
                    if (_supportResizeObserver) {
                        var element = targetElement.contents()[0];
                        element[_strResizeObserverProperty].disconnect();
                        delete element[_strResizeObserverProperty];
                    }
                    else {
                        remove(targetElement.children(_strDot + _classNameResizeObserverElement).eq(0));
                    }
                }
170004
private void removeVetoedClasses(Set<Class<?>> classes) {
        //get hold of classnames
        Set<String> classNames = new HashSet<String>();
        for (Class<?> clazz : classes) {
            classNames.add(clazz.getName());
        }
        // take into considerations of the exclude in beans.xml
        Collection<String> includedClasses = WeldCDIUtils.filterClassesBasedOnBeansXML(this.beansXml, this.resourceLoader, classNames);
        Iterator<Class<?>> iterator = classes.iterator();
        while (iterator.hasNext()) {
            Class<?> clazz = iterator.next();
            if (WeldCDIUtils.isClassVetoed(clazz)) {
                iterator.remove();
            } else if (!includedClasses.contains(clazz.getName())) {
                iterator.remove();
            }

        }
    }
1157718
public void removeSimilarClassesFromFile1() throws IOException {
        logging.info("Start reding cs File");
        List<String> linescs1 = getFileLinesAsList(csFile1);
        logging.info("Start reding cs File");
        List<String> linescs2 = getFileLinesAsList(csFile2);
        logging.info("Search classes");
        List<String> classNames1 = searchClasses(linescs1);
        logging.info("Found " + classNames1.size() + " classes");
        logging.info("Search classes");
        List<String> classNames2 = searchClasses(linescs2);
        logging.info("Found " + classNames2.size() + " classes");
        logging.info("Removing similarities from the file");
        for (String name : findSimilarClassNames(classNames1, classNames2)) {
            linescs1 = removeLinesContainingClassname(linescs1, name);
        }
        logging.info("Remove Attributes, which stands alone");
        linescs1 = removeAttributesNotBoundToClass(linescs1);
        if (!windows) {
            logging.info("Replace abstract classes with interfaces");
            linescs1 = replaceAbstractClasses(linescs1);
            linescs2 = replaceAbstractClasses(linescs2);
            logging.info("Save files");
        }
        replaceFilesWithNewContent(linescs1, csFile1);
        replaceFilesWithNewContent(linescs2, csFile2);
    }