Unregisters a filter function

@param string $type filter type
@param callback $callback
495991
public function unregisterFilter($type, $callback)
    {
        $name = $this->_get_filter_name($callback);
        if (isset($this->smarty->registered_filters[$type][$name])) {
            unset($this->smarty->registered_filters[$type][$name]);
        }
    }
1324404
public function Unlisten($signal_type, $callback)
    {
        if(!isset($this->listeners[$signal_type]))
            return;
        
        foreach($this->listeners[$signal_type] as $position=>$callback_data)
        {
            $stored_callback = $callback_data['callback'];
            
            if($callback == $stored_callback)
            {
                unset($this->listeners[$signal_type][$position]);
                return;
            }
        }
    }
1254840
public void unRegisterActivitResumeEvent(IActivityResumeCallback callback) {
        HMSAgentLog.d("unRegisterOnResume:" + StrUtils.objDesc(callback));
        resumeCallbacks.remove(callback);
    }
1228392
public function unsubscribe($name, $id = null, $callback = null) {
        $self = $this;
        if (!is_string($name)) {
            throw new TypeError('topic name must be a string');
        }
        if (($id === null) && ($callback === null)) {
            unset($this->topics[$name]);
            return;
        }
        if (is_callable($id) && !is_callable($callback)) {
            $callback = $id;
            $id = null;
        }
        if ($id === null) {
            if ($this->id === null) {
                if (isset($this->topics[$name])) {
                    $topics = $this->topics[$name];
                    $ids = array_keys($topics);
                    foreach ($ids as $id) {
                        $this->delTopic($topics, $id, $callback);
                    }
                }
            }
            else {
                $this->id->then(function($id) use ($self, $name, $callback) {
                    $self->;
                });
            }
        }
        elseif (Future\isFuture($id)) {
            $id->then(function($id) use ($self, $name, $callback) {
                $self->;
            });
        }
        else {
            $this->delTopic($this->topics[$name], $id, $callback);
        }
        if (isset($this->topics[$name]) && count($this->topics[$name]) === 0) {
            unset($this->topics[$name]);
        }
    }
1268654
def unregister(self, name: str):
        ''''''
        del self._callbacks[name]

        if self._event_dispatcher is not None:
            self._event_dispatcher.unregister(name)
161938
function removeCallbacks(src, callback, context) {
    return filter(src, function(event) {
      return (!callback || event[0] == callback) && (!context || context == event[1]);
    });
  }
44400
public static function extend($type, $callback=null)
    {
        if (is_array($type)) {
            self::$type=array_merge(self::$type, $type);
        } else {
            self::$type[$type]=$callback;
        }
    }
408453
function off(string $event, $callback): bool
    {
        return $this->getEventEmitter()->off($event, $callback);
    }
649324
public function detach($event, $callback)
    {
        if (null !== $callback) {
            $oid = $this->hashCallable($callback);
            if (isset($this->callable_map[$event][$oid])) {
                $callback = $this->callable_map[$event][$oid];
                unset($this->callable_map[$event][$oid]);
            }
        } else {
            unset($this->callable_map[$event]);
        }
        return parent::detach($event, $callback);
    }
1071276
function removeFilter (config, filter) {
  if (filter) {
    if (config.filters.ignore[ filter ]) {
      delete config.filters.ignore[ filter ]
    } else {
      delete config.filters.should[ filter ]
    }
  }
}
203333
public static function removeHeader($type) {
		
		if(false == is_string($type)) {
			return trigger_error(sprintf('Argument 1 passed to %s() must be of the type string, "%s" given', __METHOD__, gettype($type)), E_USER_ERROR);
		}

		header_remove($type);
	}
816543
public function unregisterShutdownFunction($callback)
    {
        if (($k = array_search($callback, $this->shutdownFuncs)) !== false) {
            unset($this->shutdownFuncs[$k]);
        }
    }
927203
public static <T extends Tag, V> void unregister(Class<T> tag, Class<V> type) {
        tagToConverter.remove(tag);
        typeToConverter.remove(type);
    }
863285
public function deleteService( $type )
	{
		$this->_notifyListeners( 'deleteService.before', $type );

		if( isset( $this->_services[$type] ) ) {
			unset( $this->_services[$type] );
			$this->_modified = true;
		}

		$this->_notifyListeners( 'deleteService.after', $type );
	}
1196372
@Override
	public void removeCallback(Callback callback) {
		callbacks.remove(callback);
		if (manager != null) {
			callback.cleanup();
		}
	}
1267276
def removeCallback(cls, eventType, func, record=None):
        
        callbacks = cls.callbacks()
        callbacks.setdefault(eventType, [])
        for i in xrange(len(callbacks[eventType])):
            my_func, my_record, _ = callbacks[eventType][i]
            if func == my_func and record == my_record:
                del callbacks[eventType][i]
                break
1295105
public function addFilterCallback($callback, $flags = null)
    {
        $flags = (int) $flags;

        if ($flags & self::FILTER_REPLACE_ENTRY) {
            $this->filterEntryCallbacks = [];
        }

        if ($flags & self::FILTER_REPLACE_EXIT) {
            $this->filterExitCallbacks = [];
        }

        // Called when entry records came
        if (($flags & self::FILTER_ENTRY) || !($flags & self::FILTER_EXIT)) {
            if ($flags & self::FILTER_APPEND_ENTRY) {
                $this->filterEntryCallbacks[] = $callback;

            } else {
                \array_unshift($this->filterEntryCallbacks, $callback);
            }
        }

        // Called when exit records came
        if ($flags & self::FILTER_EXIT) {
            if ($flags & self::FILTER_APPEND_EXIT) {
                $this->filterExitCallbacks[] = $callback;

            } else {
                \array_unshift($this->filterExitCallbacks, $callback);
            }
        }
    }