Clears all STRACE events.

        Args:
          self (JLink): the ``JLink`` instance.

        Returns:
          ``None``

        Raises:
          JLinkException: on error.
777998
def strace_clear_all(self):
        
        data = 0
        res = self._dll.JLINK_STRACE_Control(enums.JLinkStraceCommand.TRACE_EVENT_CLR_ALL, data)
        if res < 0:
            raise errors.JLinkException('Failed to clear all STRACE events.')

        return None
537837
def clear(self):
        
        with self.__bnd_lock:
            self.__bnd_listeners = []

        with self.__svc_lock:
            self.__svc_listeners.clear()

        with self.__fw_lock:
            self.__fw_listeners = []
290745
public void clear()
  {
    _nullValue = NULL;
    
    for (int i = 0; i < _values.length; i++) {
      _keys[i] = null;
      _flags[i] = 0;
      _values[i] = 0;
    }
    
    _size = 0;
  }
1199287
def clear(self, event, ts=None):
        
        return self.r.delete(self._keygen(event, ts))
379603
public void clear() {

        if (m_handlerRegistration != null) {
            m_handlerRegistration.removeHandler();
            m_handlerRegistration = null;
        }
        m_changeListeners.clear();
        m_scopeValues.clear();
        m_observerdEntity = null;
    }
864057
def clear_events(self, event_name):
        
        self.lock.acquire()
        try:
            q = self.get_event_q(event_name)
            q.queue.clear()
        except queue.Empty:
            return
        finally:
            self.lock.release()
1316364
public void reset() {
		unused.addAll(templateNegative);
		unused.addAll(templatePositive);
		templateNegative.clear();
		templatePositive.clear();
	}
708298
protected final void clearReadPending() {
        if (isRegistered()) {
            EventLoop eventLoop = eventLoop();
            if (eventLoop.inEventLoop()) {
                readPending = false;
            } else {
                eventLoop.execute(clearReadPendingRunnable);
            }
        } else {
            // Best effort if we are not registered yet clear readPending. This happens during channel initialization.
            readPending = false;
        }
    }
218121
def clear(self) -> None:
        

        LOGGER.debug('SchemaCache.clear >>>')

        self._schema_key2schema = {}
        self._seq_no2schema_key = {}

        LOGGER.debug('SchemaCache.clear <<<')
812341
public void reset() {
        javaByteCode = null;
        enhancedByteCode = null;
        javaSource = null;
        templateInstance = null;
        for (TemplateClass tc : embeddedClasses) {
            tc.reset();
            engine().classes().remove(tc);
        }
        embeddedClasses.clear();
        engine().classCache().deleteCache(this);
        engine().invalidate(this);
        javaClass = null;
    }
949935
def clear(self):
        
        # The del_binfo() call here isn't necessary for normal execution,
        # but is for interactive mode, where we might rebuild the same
        # target and need to start from scratch.
        self.del_binfo()
        self.clear_memoized_values()
        self.ninfo = self.new_ninfo()
        self.executor_cleanup()
        try:
            delattr(self, '_calculated_sig')
        except AttributeError:
            pass
        self.includes = None
402975
public void clear() {
		// clear properties
		List<String> ownProps = getOwnProperties();
		
		for (String key : properties.keySet().toArray(new String[]{})) {
			if (ownProps.contains(key)) {
				Object value = properties.get(key);
				if (value instanceof JsonCollection) {
					JsonCollection entity = (JsonCollection)value;
					entity.clear();
				} else {
					remove(key);	
				}
			} else {
				remove(key);
			}
		}
		
		// clear fields
		for (Field field : getFields(this.getClass())) {
			if (field != null && JsonCollection.class.isAssignableFrom(field.getType())) {
				try {
					field.setAccessible(true);
					JsonCollection entity = (JsonCollection) field.get(this);
					entity.clear();
				} catch (Exception e) {
					log.error(e);
				}
			}
		}
		
		// clear sort order
		sortOrder.clear();
	}
1264570
public function clear()
    {
        $this->id = null;
        $this->code = null;
        $this->created_at = null;
        $this->updated_at = null;
        $this->version = null;
        $this->version_created_at = null;
        $this->version_created_by = null;
        $this->person_function_link_ids = null;
        $this->person_function_link_ids_unserialized = null;
        $this->person_function_link_versions = null;
        $this->person_function_link_versions_unserialized = null;
        $this->alreadyInSave = false;
        $this->clearAllReferences();
        $this->applyDefaultValues();
        $this->resetModified();
        $this->setNew(true);
        $this->setDeleted(false);
    }
1015939
public void clear() {
        Node<T> node = head.next, next;
        size = 0;
        head.reset(); // Clearing references.
        tail = head;
        iterator.currentNode = head;
        while (node != null) {
            next = node.next;
            node.free(pool);
            node = next;
        }
    }
455154
def clear(self):
        '''
        
        '''
        self._mimetype_functions = list(self._default_mimetype_functions)
        super(MimetypePluginManager, self).clear()
33547
def removeEventListener(self, event: str, listener: _EventListenerType
                            ) -> None:
        
        self._remove_event_listener(event, listener)
1302111
def clear_instance_cache(cls, func):
        

        @functools.wraps(func)
        def func_wrapper(*args, **kwargs):
            if not args:
                raise ValueError('`self` is not available.')
            else:
                the_self = args[0]

            cls.clear_self_cache(the_self)
            return func(*args, **kwargs)

        return func_wrapper