Overloaded method with 'replace' parameter set to false.
See:
{@link MBeanUtil#registerMBean(Object, String, boolean)}
16978
public String registerMBean(Object bean, String name)
            throws MalformedObjectNameException, NotCompliantMBeanException, MBeanRegistrationException {
        return registerMBean(bean, name, false);
    }
747602
public static <T extends AbstractJaxb> boolean replaceById(String id,
            T target, T replace) throws TagTypeUnmatchException {
        return execute(id, target, replace.copy(replace.getClass()));
    }
123806
@Override
    public boolean replace(K key, V oldValue, V newValue) {
        int hash = hash(key);
        if (oldValue == null || newValue == null) {
          throw new NullPointerException();
        }
        Segment<K,V> s = segmentForHash(hash);
        return s != null && s.replace(key, hash, oldValue, newValue);
    }
644087
public final <T> boolean replace(final String key, final int exp, final T value,
      final Transcoder<T> transcoder)
      throws TimeoutException, InterruptedException, MemcachedException {
    return this.replace(key, exp, value, transcoder, this.opTimeout);
  }
293782
void registerMBean(final String storageId) {
    // We wrap to bypass standard mbean naming convetion.
    // This wraping can be removed in java 6 as it is more flexible in
    // package naming for mbeans and their impl.
    StandardMBean bean;
    String storageName;
    if (storageId == null || storageId.equals("")) {// Temp fix for the uninitialized storage
      storageName = "UndefinedStorageId" + rand.nextInt();
    } else {
      storageName = storageId;
    }
    try {
      bean = new StandardMBean(this,FSDatasetMBean.class);
      mbeanName = MBeanUtil.registerMBean("DataNode", "FSDatasetState-" + storageName, bean);
      versionBeanName = VersionInfo.registerJMX("DataNode");
    } catch (NotCompliantMBeanException e) {
      e.printStackTrace();
    }

    DataNode.LOG.info("Registered FSDatasetStatusMBean");
  }
704071
def replace(self, parameters=_void, return_annotation=_void):
        

        if parameters is _void:
            parameters = self.parameters.values()

        if return_annotation is _void:
            return_annotation = self._return_annotation

        return type(self)(parameters, return_annotation=return_annotation)
970588
public void register(final String word, final String replacement) {
        ArgUtils.notEmpty(word, "word");
        ArgUtils.notNull(replacement, "replacement");
        
        if(word.length() == 1) {
            singles.computeIfAbsent(word.charAt(0), key -> replacement);
            
        } else {
            multi.add(new MultiChar(word, replacement));
        }
        
    }
1337505
private void initMBean()  {
        try {
            registerMBean(this,getObjectName());
        } catch (InstanceAlreadyExistsException exp) {
            // This is no problem, since this MBeanServerHandlerMBean holds only global information
            // with no special state (so all instances of this MBean behave similar)
            // This exception can happen, when multiple servlets get registered within the same JVM
        } catch (MalformedObjectNameException e) {
            // Cannot happen, otherwise this is a bug. We should be always provide our own name in correct
            // form.
            throw new IllegalStateException("Internal Error: Own ObjectName " + getObjectName() + " is malformed",e);
        } catch (NotCompliantMBeanException e) {
            // Same here
            throw new IllegalStateException("Internal Error: " + this.getClass().getName() + " is not a compliant MBean",e);
        }
    }
1218366
public synchronized void replace(final BioPAXElement existing, final BioPAXElement replacement) 
	{
		 ModelUtils.replace(this, Collections.singletonMap(existing, replacement));
		 remove(existing);
		 if(replacement != null)
			 add(replacement);
	}
1229561
public synchronized void registerSignal(int signalNumber, Runnable callback, boolean replace) {
        String signalName = signalMap.get(signalNumber);
        if (signalName == null) {
            LOG.warn("Invalid signalNumber " + signalNumber);
            return;
        }

        LOG.info("Begin to register signal of {}", signalName);
        try {
            SignalHandler oldHandler = Signal.handle(new Signal(signalName), this);
            LOG.info("Successfully register {} handler", signalName);

            Runnable old = signalHandlers.put(signalNumber, callback);
            if (old != null) {
                if (!replace) {
                    oldSignalHandlers.put(signalNumber, oldHandler);

                } else {
                    LOG.info("Successfully old {} handler will be replaced", signalName);
                }

            }
            LOG.info("Successfully register signal of {}", signalName);
        } catch (Exception e) {
            LOG.error("Failed to register " + signalName + ":" + signalNumber + ", Signal already used by VM or OS: SIGILL");
        }

    }
455163
public <E extends Exception> void replaceAll(Try.BiFunction<? super T, ? super Integer, Integer, E> function) throws E {
        List<T> keyToRemove = null;
        Integer newVal = null;

        for (Map.Entry<T, MutableInt> entry : this.valueMap.entrySet()) {
            newVal = function.apply(entry.getKey(), entry.getValue().value());

            if (newVal == null || newVal.intValue() <= 0) {
                if (keyToRemove == null) {
                    keyToRemove = new ArrayList<>();
                }

                keyToRemove.add(entry.getKey());
            } else {
                entry.getValue().setValue(newVal);
            }
        }

        if (N.notNullOrEmpty(keyToRemove)) {
            for (T key : keyToRemove) {
                valueMap.remove(key);
            }
        }
    }
715458
public void register(BeanMappingObject object) {
        BeanMappingObject old = null;
        String name = null;
        if (object != null) {
            if (StringUtils.isEmpty(object.getName())) {
                name = mapperObjectName(object.getSrcClass(), object.getTargetClass());
            } else {
                name = object.getName();
            }

            old = mappings.put(name, object);
        }

        if (old != null) {
            logger.warn("{} has been replaced by : {}", name, object.toString());
        }
    }
400821
boolean declareParam(JSTypeExpression jsType, String parameter) {
    lazyInitInfo();
    if (info.parameters == null) {
      info.parameters = new LinkedHashMap<>();
    }
    if (!info.parameters.containsKey(parameter)) {
      info.parameters.put(parameter, jsType);
      return true;
    } else {
      return false;
    }
  }
255827
public static String replace(final CharSequence target, final CharSequence replacement, final String string) {
    return Pattern.compile(quote(target.toString())/*
                                                    * , Pattern.LITERAL jdk 1.4
                                                    */).matcher(string).replaceAll(
    /* Matcher. jdk 1.4 */quoteReplacement(replacement.toString()));
  }
1007875
public boolean replace(K key, V oldValue, V newValue) {
        if (oldValue == null || newValue == null) {
            throw new NullPointerException();
        }
        int hash = this.hashOf(key);
        return this.segmentFor(hash).replace(key, hash, oldValue, newValue);
    }
347657
private static void replaceParameters(Term t, StringBuilder b) {
        FunctionEnum f = t.getFunctionEnum();
        String fx = f.getShortestForm();
        b.append(fx).append("(");
        if (hasItems(t.getFunctionArguments())) {
            for (BELObject bo : t.getFunctionArguments()) {
                if (Term.class.isAssignableFrom(bo.getClass())) {
                    Term inner = (Term) bo;
                    if (inner.getFunctionEnum() == PROTEIN_MODIFICATION ||
                        inner.getFunctionEnum() == SUBSTITUTION ||
                        inner.getFunctionEnum() == TRUNCATION) {
                        b.append(inner.toBELShortForm());
                    } else {
                        replaceParameters((Term) bo, b);
                    }
                } else {
                    b.append("#");
                }
                b.append(",");
            }
            b.deleteCharAt(b.length() - 1);
            b.append(")");
        }
    }
1139228
private MapEntryUpdateResult<K, byte[]> replaceIf(
      long index, K key, MapEntryValue newValue, Predicate<MapEntryValue> predicate) {
    MapEntryValue oldValue = entries().get(key);

    // If the key is not set or the current value doesn't match the predicate, return a PRECONDITION_FAILED error.
    if (valueIsNull(oldValue) || !predicate.test(oldValue)) {
      return new MapEntryUpdateResult<>(
          MapEntryUpdateResult.Status.PRECONDITION_FAILED,
          index,
          key,
          toVersioned(oldValue));
    }

    // If the key has been locked by a transaction, return a WRITE_LOCK error.
    if (preparedKeys.contains(key)) {
      return new MapEntryUpdateResult<>(MapEntryUpdateResult.Status.WRITE_LOCK, index, key, null);
    }

    putValue(key, newValue);
    Versioned<byte[]> result = toVersioned(oldValue);
    publish(new AtomicMapEvent<>(AtomicMapEvent.Type.UPDATE, key, toVersioned(newValue), result));
    return new MapEntryUpdateResult<>(MapEntryUpdateResult.Status.OK, index, key, result);
  }