Remove unnecessary class definitions: definitions of SKOS classes or
       unused classes. If a class is also a skos:Concept or skos:Collection,
       remove the 'classness' of it but leave the Concept/Collection.
338997
def cleanup_classes(rdf):
    """"""
    for t in (OWL.Class, RDFS.Class):
        for cl in rdf.subjects(RDF.type, t):
            # SKOS classes may be safely removed
            if cl.startswith(SKOS):
                logging.debug("removing SKOS class definition: %s", cl)
                replace_subject(rdf, cl, None)
                continue
            # if there are instances of the class, keep the class def
            if rdf.value(None, RDF.type, cl, any=True) is not None:
                continue
            # if the class is used in a domain/range/equivalentClass
            # definition, keep the class def
            if rdf.value(None, RDFS.domain, cl, any=True) is not None:
                continue
            if rdf.value(None, RDFS.range, cl, any=True) is not None:
                continue
            if rdf.value(None, OWL.equivalentClass, cl, any=True) is not None:
                continue

            # if the class is also a skos:Concept or skos:Collection, only
            # remove its rdf:type
            if (cl, RDF.type, SKOS.Concept) in rdf \
               or (cl, RDF.type, SKOS.Collection) in rdf:
                logging.debug("removing classiness of %s", cl)
                rdf.remove((cl, RDF.type, t))
            else:  # remove it completely
                logging.debug("removing unused class definition: %s", cl)
                replace_subject(rdf, cl, None)
1106009
function(anew, old, className) {
      if (old) {
        old.classList.remove(className);
      }
      if (anew) {
        anew.classList.add(className);
      }
    }
1140935
def unhumanize_class(my_classes):
    """"""
    result = []
    interval = my_classes[-1] - my_classes[-2]
    min_value = 0
    for max_value in my_classes:
        result.append((format_decimal(interval, min_value),
                       format_decimal(interval, max_value)))
        min_value = max_value
    return result
578592
def remove_css_class(css_classes, css_class):
    
    remove = set(split_css_classes(css_class))
    classes_list = [c for c in split_css_classes(css_classes) if c not in remove]
    return " ".join(classes_list)
660998
function removeClasses() {
      var classes = Glide.settings.classes;

      Components.Html.root.classList.remove(classes[Glide.settings.type]);

      Components.Html.slides.forEach(function (sibling) {
        sibling.classList.remove(classes.activeSlide);
      });
    }
1055822
function _fnSortingClasses( settings )
	{
		var oldSort = settings.aLastSort;
		var sortClass = settings.oClasses.sSortColumn;
		var sort = _fnSortFlatten( settings );
		var features = settings.oFeatures;
		var i, ien, colIdx;
	
		if ( features.bSort && features.bSortClasses ) {
			// Remove old sorting classes
			for ( i=0, ien=oldSort.length ; i<ien ; i++ ) {
				colIdx = oldSort[i].src;
	
				// Remove column sorting
				$( _pluck( settings.aoData, 'anCells', colIdx ) )
					.removeClass( sortClass + (i<2 ? i+1 : 3) );
			}
	
			// Add new column sorting
			for ( i=0, ien=sort.length ; i<ien ; i++ ) {
				colIdx = sort[i].src;
	
				$( _pluck( settings.aoData, 'anCells', colIdx ) )
					.addClass( sortClass + (i<2 ? i+1 : 3) );
			}
		}
	
		settings.aLastSort = sort;
	}
152189
private static Set<Class<?>> describeClassTree(Class<?> inputClass) {
    if(inputClass == null) {
      return Collections.emptySet();
    }

    // create result collector
    Set<Class<?>> classes = Sets.newLinkedHashSet();

    // describe tree
    describeClassTree(inputClass, classes);

    return classes;
  }
476025
def remove_class(self, ioclass):
        """"""
        current_ioclasses = self.ioclasses
        new_ioclasses = filter(lambda x: x.name != ioclass.name,
                               current_ioclasses)
        self.modify(new_ioclasses=new_ioclasses)
624630
def keep(classes)
      @by_id.each.with_index do |klass, id|
        unless classes.include?(klass)
          # Delete the class from the @by_id list by setting the entry to nil.
          @by_id[id] = nil
          # Delete the corresponding @by_class entry as well.
          @by_class.delete(klass)
        end
      end
    end
180591
def unused(self):
    """"""
    unused = self.definitions - self.used
    # Filter (variable_name,node) pairs that should be removed, because
    # node is used elsewhere
    used_nodes = set([u[1] for u in self.used])
    unused = set([u for u in unused if u[1] not in used_nodes])
    return unused
221398
def class_defined(filename, class_name, superclass_name)
      @definition_graph[filename] ||= {}
      @definition_graph[filename][class_name] = superclass_name
      class_encountered(filename, class_name)
      class_encountered(filename, superclass_name) if superclass_name
    end
788759
def subclasses(cls):
        """"""
        seen = set()
        queue = set([cls])

        while queue:
            c = queue.pop()
            seen.add(c)

            sc = c.__subclasses__()
            for c in sc:
                if c not in seen:
                    queue.add(c)

        seen.remove(cls)
        return seen
1198419
def _unregister(self, cls):
        
        if not issubclass(cls, self._registerable_class):
            raise ValueError('Only %s classes or subclasses may be '
                             'unregistered.' % self._registerable_class)

        if cls not in self._registry:
            raise NotRegistered('%s is not registered' % cls)

        del self._registry[cls]

        return True
463567
@PreDestroy
	public void removeGeneratedClasses() {
		ClassPool pool = ClassPool.getDefault();
		for (Class<?> clazz : interfaces.values()) {
			CtClass ctClass = pool.getOrNull(clazz.getName());
			if (ctClass != null) {
				ctClass.detach();
				logger.debug("class {} is detached", clazz.getName());
			}
		}
	}
416784
function (suggestionNode, className) {
            var suggestionNodeClassList = new aria.utils.ClassList(suggestionNode);
            suggestionNodeClassList.remove(className);
            suggestionNodeClassList.$dispose();
        }
800898
function () {
            var features = document.querySelectorAll('.feature-with-scenarios');
            for (var i = 0; i < features.length; i++) {
                features[i].classList.remove('hidden');
            }
        }
1101454
function removeUnusedProperties(node) {
    if (typeof node !== "object") {
        return;
    }
    ["position"].forEach(function (key) {
        if (node.hasOwnProperty(key)) {
            delete node[key];
        }
    });
}