/*
(non-Javadoc)

@see
org.apache.bcel.util.Repository#removeClass(org.apache.bcel.classfile
.JavaClass)
174630
@Override
    public void removeClass(JavaClass javaClass) {
        nameToClassMap.remove(javaClass.getClassName());
        if (DEBUG) {
            System.out.println("Removing class " + javaClass.getClassName() + " from Repository");
            dumpStack();
        }
    }
573878
public void removeObjectListeners(Class<?> objectClass, long objectId) {
        if (objectClass == null) {
            return;
        }
        synchronized (objectListeners) {
            Map<Long, Map<Class<? extends ObjectAttachableListener>,
                    Map<ObjectAttachableListener, ListenerManagerImpl<? extends ObjectAttachableListener>>>>
                    objects = objectListeners.get(objectClass);
            if (objects == null) {
                return;
            }
            // Remove all listeners
            objects.computeIfPresent(objectId, (id, listeners) -> {
                listeners.values().stream()
                        .flatMap(map -> map.values().stream())
                        .forEach(ListenerManagerImpl::removed);
                listeners.clear();
                return null;
            });
            // Cleanup
            if (objects.isEmpty()) {
                objectListeners.remove(objectClass);
            }
        }
    }
277103
public function removeClassProperty()
    {
        $success = false;
        if(!$this->isXmlHttpRequest()){
            throw new common_exception_BadRequest('wrong request mode');
        }

        $class = $this->getClass($this->getRequestParameter('classUri'));
        $property = $this->getProperty($this->getRequestParameter('uri'));

        //delete property mode
        foreach($class->getProperties() as $classProperty) {
            if ($classProperty->equals($property)) {

                $indexes = $property->getPropertyValues($this->getProperty(OntologyIndex::PROPERTY_INDEX));
                //delete property and the existing values of this property
                if($property->delete(true)){
                    //delete index linked to the property
                    foreach($indexes as $indexUri){
                        $index = $this->getResource($indexUri);
                        $index->delete(true);
                    }
                    $success = true;
                    break;
                }
            }
        }

        if ($success) {
            $this->returnJson(array(
                'success' => true
            ));
            return;
        } else {
            $this->returnError(__('Unable to remove the property.'));
        }
    }
943330
@Override
  public <T> List<T> remove(Collection<? extends T> batchToRemove, Class<T> entityClass) {
    return remove(batchToRemove, Util.determineCollectionName(entityClass));
  }
656955
public <T extends JobProperty> T removeProperty(Class<T> clazz) throws IOException {
        for (JobProperty<? super JobT> p : properties) {
            if (clazz.isInstance(p)) {
                removeProperty(p);
                return clazz.cast(p);
            }
        }
        return null;
    }
872482
public void removeAsDelayable(NonDelayedClassInfo classInfo) {
        String methodName = "removeAsDelayable";

        boolean doLog = tc.isDebugEnabled();
        String useHashText = (doLog ? getHashText() : null);
        String useClassHashText = (doLog ? classInfo.getHashText() : null);

        if (doLog) {
            logLinks(methodName, classInfo);
        }

        if (firstClassInfo == null) {
            Tr.debug(tc, MessageFormat.format("[ {0} ] Ignoring remove request; no linked classes [ {1} ]",
                                              new Object[] { useHashText, useClassHashText }));
            return;
        }

        NonDelayedClassInfo currentPrior = classInfo.getPriorClassInfo();
        NonDelayedClassInfo currentNext = classInfo.getNextClassInfo();

        // The only way for both the current prior can be null is for the class to be the singleton
        // first class.  So, if the class is not the first class, and its prior and next are both
        // null, then it is not linked.

        if ((firstClassInfo != classInfo) && (currentPrior == null) && (currentNext == null)) {
            Tr.debug(tc, MessageFormat.format("[ {0} ] Ignoring remove request; not yet linked [ {1} ]",
                                              new Object[] { useHashText, useClassHashText }));
            return;
        }

        if (currentPrior != null) {
            currentPrior.setNextClassInfo(currentNext);
        } else {
            firstClassInfo = currentNext;
        }

        if (currentNext != null) {
            currentNext.setPriorClassInfo(currentPrior);
        } else {
            lastClassInfo = currentPrior;
        }

        // Clear the prior and next pointers to indicate the ClassInfo is no longer linked
        classInfo.setPriorClassInfo(null);
        classInfo.setNextClassInfo(null);

        // Remove the class from the delayable collection
        classInfos.remove(classInfo.getName());

        // the NonDelayedClassInfo needs to be in one of the ClassInfo maps. It was just removed 
        // from the delayable map (classInfos) therefore is not a primitive object so the 
        // primitiveClassInfos map is not applicable. The only reason to make it nondelayable is 
        // because an annotation has been found, so we will add it to the annotatedClassInfos map.
        basicPutAnnotatedClassInfo(classInfo);

        if (doLog) {
            // Note: The extra '== null' and '!= null' tests are
            //       present because the eclipse compiler is not
            //       smart enough to use all of the test conditions
            //       when doing null pointer analysis in each of the
            //       blocks.  The extra checks avoid compiler warnings.

            if ((currentPrior == null) && (currentNext == null)) {
                Tr.debug(tc, MessageFormat.format("[ {0} ] Removing as singleton [ {1} ]",
                                                  new Object[] { useHashText, useClassHashText }));

            } else if ((currentPrior == null) && (currentNext != null)) {
                Tr.debug(tc, MessageFormat.format("[ {0} ] Removing as first [ {1} ]",
                                                  new Object[] { useHashText, useClassHashText }));
                Tr.debug(tc, MessageFormat.format("[ {0} ] New first [ {1} ]",
                                                  new Object[] { useHashText, currentNext.getHashText() }));

            } else if ((currentPrior != null) && (currentNext == null)) {
                Tr.debug(tc, MessageFormat.format("[ {0} ] Removing as last [ {1} ]",
                                                  new Object[] { useHashText, useClassHashText }));
                Tr.debug(tc, MessageFormat.format("[ {0} ] New last [ {1} ]",
                                                  new Object[] { useHashText, currentPrior.getHashText() }));

            } else if ((currentPrior != null) && (currentNext != null)) {
                Tr.debug(tc, MessageFormat.format("[ {0} ] Removing from middle [ {1} ]",
                                                  new Object[] { useHashText, useClassHashText }));

                Tr.debug(tc, MessageFormat.format("[ {0} ] Old prior [ {1} ]",
                                                  new Object[] { useHashText, currentPrior.getHashText() }));
                Tr.debug(tc, MessageFormat.format("[ {0} ] Old next [ {1} ]",
                                                  new Object[] { useHashText, currentNext.getHashText() }));
            }
        }
    }
158948
function removeClass() {
      Components.Html.root.classList.remove(Glide.settings.classes.direction[this.value]);
    }
320428
public boolean remove(String classname) {
    String		pkgname;
    HashSet<String>	names;

    classname = ClassPathTraversal.cleanUp(classname);
    pkgname   = ClassPathTraversal.extractPackage(classname);
    names     = m_NameCache.get(pkgname);
    if (names != null)
      return names.remove(classname);
    else
      return false;
  }
800839
function removeClass(className) {
  if(!className) {
    // remove all classes from all matched elements
    this.each(function(el) {
      el.removeAttribute(attr);
    });
    return this;
  }
  var classes = className.split(/\s+/);
  this.each(function(el) {
    var val = el.getAttribute(attr);
    // no class attribute - nothing to remove
    if(!val) {
      return;
    }
    var names = val.split(/\s+/);
    names = names.filter(function(nm) {
      return ~classes.indexOf(nm) ? false : nm;
    });
    el.setAttribute(attr, names.join(' '));
  });
  return this;
}
806643
def remove_class(self, cls):
        
        del self._tag_map[cls.TAG]
        del self._class_map[cls]
1290309
@Override
	public void remove(final Object key, final Class<?> clas) {
		this.logger.debug("@remove :".concat(key.toString()).concat(" with class : ".concat(clas.getName())));
		getCachableMap(clas).remove(key);
	}
792833
public function removeClass($className)
  {
    $pos = array_search($className, $this->classes);
    if (is_numeric($pos)) {
      unset($this->classes[$pos]);
      return true;
    }
    return false;
  }
214534
function removeClass(element, className) {
  let elements = [].concat(element);
  let classes = [];
  let n = elements.length;

  if (!assert((typeof className === 'string') || (className instanceof Array), 'Invalid class name specified. Must be either a string or an array of strings.')) return;

  if (typeof className === 'string') {
    classes.push(className);
  }
  else {
    classes = className;
  }

  let nClasses = classes.length;

  for (let i = 0; i < n; i++) {
    let e = elements[i];

    for (let j = 0; j < nClasses; j++) {
      let c = classes[j];

      if (!assert(typeof c === 'string', 'Invalid class detected: ' + c)) continue;

      let regex = new RegExp('^' + c + '\\s+|\\s+' + c + '|^' + c + '$', 'g');
      e.className = e.className.replace(regex, '');
    }

    if (e.className === '') {
      e.removeAttribute('class');
    }
  }
}
143745
public void remove(Class<? extends T> type) throws IOException {
        for (T t : data) {
            if(t.getClass()==type) {
                data.remove(t);
                onModified();
                return;
            }
        }
    }
808249
public void remove(T element, Class<?> accessibleClass) {
		while (accessibleClass != null && accessibleClass != this.baseClass) {
			this.removeSingle(element, accessibleClass);

			for (Class<?> interf : accessibleClass.getInterfaces()) {
				this.removeSingle(element, interf);
			}

			accessibleClass = accessibleClass.getSuperclass();
		}
	}
1194579
public function remove_class( $class ) {
		if ( !isset( $this->attr['class'] ) || !is_array( $this->attr['class'] ) ) {
			$this->_sanitize_class();
		}
		$this->attr['class'] = array_diff( $this->attr['class'], array( $class ) );
		return $this;
	}
1288795
protected final <T extends EventListener> void removeListener(Class<T> listenerType, T listener) {
		if (this.listeners != null) {
			this.listeners.remove(listenerType, listener);
			if (this.listeners.isEmpty()) {
				this.listeners = null;
			}
		}
	}