Removes and returns the given event log.

@param type the log type
@param name the log name
@param <L> the listener type
@param <E> the event type
@return the removed event log or {@code null} if non exits
197343
@SuppressWarnings("unchecked")
  public <L, E> EventLog<L, E> removeEventLog(Class<?> type, String name) {
    return eventRegistries.computeIfAbsent(type, t -> new ConcurrentHashMap<>()).remove(name);
  }
595431
public ErrorLogger getLog(final String name) {
        return hasLog(name) ? logs.get(name) : null;
    }
1158706
@SuppressWarnings("unchecked")
  public static <T extends LogEventListener> T removeListener(String name) {
    Map<String, LogEventListener> listeners = SelenideLogger.listeners.get();
    return listeners == null ? null : (T) listeners.remove(name);
  }
269725
static public function getByType($type, $name = null, $inherit=false)
    {
        // first get [logs.xxx], then [xxx.log]
        if (!($value = static::get($type . 's.' . $name))) {
            if (!($value = static::get($name . '.' . $type))) {
                $value = static::get($type, $name, $inherit);
            }
        }
        
        return $value;
    }
872346
public synchronized <T extends EventListener> void remove(Class<T> type, T listener) {
		assert listener != null;
		// Is l on the list?
		int index = -1;
		for (int i = this.listeners.length - 2; i >= 0; i -= 2) {
			if ((this.listeners[i] == type) && (this.listeners[i + 1].equals(listener))) {
				index = i;
				break;
			}
		}

		// If so,  remove it
		if (index != -1) {
			final Object[] tmp = new Object[this.listeners.length - 2];
			// Copy the list up to index
			System.arraycopy(this.listeners, 0, tmp, 0, index);
			// Copy from two past the index, up to
			// the end of tmp (which is two elements
			// shorter than the old list)
			if (index < tmp.length) {
				System.arraycopy(this.listeners, index + 2, tmp, index,
						tmp.length - index);
			}
			// set the listener array to the new array or null
			this.listeners = (tmp.length == 0) ? NULL : tmp;
		}
	}
481346
public <V,T extends RiakIndex<V>> T removeIndex(RiakIndex.Name<T> name)
    {
        RiakIndex<?> removed = indexes.remove(name.getFullname());
        if (removed != null)
        {
            T index = name.wrap(removed).createIndex();
            return index;
        }
        else
        {
            return null;
        }
    }
1041409
function ( el, type, handler ) {
                if ( _hasDomEvent ) {
                    this._removeEventListener = function ( el, type, handler ) {
                        el.removeEventListener( getCrossType(type), handler, false );
                    };
                } else if ( _hasIEEvent ) {
                    this._removeEventListener = function ( el, type, handler ) {
                        el.detachEvent( 'on' + type, handler );
                    };
                }
                this._removeEventListener( el, type, handler );
            }
1094436
public void remove_logging_target(String target_type, String target_name) throws DevFailed {
        deviceProxyDAO.remove_logging_target(this, target_type, target_name);
    }
1366078
public static <T> Parameters.Builder<T> logger(String name) {
        return Parameters.<T> builder().name(name);
    }
1325744
public static TraceEvent getType(List<TraceEvent> events, int... types)
   {
      return getType(events, null, types);
   }
1134130
public @Nullable <T> T get(@NotNull String name, @NotNull Class<T> type) {
    return getForComponent(component, name, type);
  }
991602
public static MjdbcLogger getLogger(String name) {
        MjdbcLogger mjdbcLogger = new MjdbcLogger(name, null);

        if (isSLF4jAvailable() == true) {
            try {
                mjdbcLogger = new MjdbcLogger(name, null);
                mjdbcLogger.setSlfLogger(MappingUtils.invokeStaticFunction(Class.forName("org.slf4j.LoggerFactory"), "getLogger", new Class[]{String.class}, new Object[]{name}));
            } catch (MjdbcException e) {
                setSLF4jAvailable(false);
            } catch (ClassNotFoundException e) {
                setSLF4jAvailable(false);
            }
        }

        return mjdbcLogger;
    }
1059814
public ParsedField getParsableField(final String type, final String name) {
        return cache.get(ParsedField.makeId(type, name));
    }
902413
private void logEvent(Node node, EventType eventType)
    {
        // Node contains original as well as transactional copy.
        EventLog log = new EventLog(eventType, node);
        eventLogQueue.onEvent(log, eventType);
    }
57915
protected Type<?> loadType( String name )
    {
        Type<?> type = typeLoader.loadType( name );
        if (type == null) throw new TypeNotFoundException( name , this.getClass());
        return type;
    }
59783
function(type, callback) {
        var listeners = this.__getEventListener(type);
        for (var i = 0; i < listeners.length; i++) {
            if (callback === listeners[i]) {
                listeners.splice(i--, 1);
            }
        }
        return this;
    }
598007
public static Logger getLogger(String name) {
        Logger logger = Logger.getLogger(name);
        logger.setUseParentHandlers(false);
        for (Handler handler : logger.getHandlers()) {
            logger.removeHandler(handler);
        }
        // TODO when output log to the standard error
        Formatter formatter = new Formatter() {
            @Override
            public String format(LogRecord record) {
                long millis = record.getMillis();
                return String.format("[%tF %<tT.%<tL]%s%n", millis, record.getMessage());
            }
        };
        ConsoleHandler handler = new ConsoleHandler();
        handler.setFormatter(formatter);
        logger.addHandler(handler);
        if (loggerEnabled) {
            logger.setLevel(Level.INFO);
        } else {
            logger.setLevel(Level.OFF);
        }
        return logger;
    }