Examples of replace()

• adipe.translate.sql.ColumnIndexesImpl.replace()
• adipe.translate.sql.ColumnNamesImpl.replace()
• alt.jiapi.reflect.InstructionList.replace()
  Replace an Instruction at given index @param idx Index of the Instruction to replace @param idx Index of the Instruction to replace
• ariba.util.core.FastStringBuffer.replace()
  Replaces value at index. If index + value.length() is greater than or equal to the number of characters within the buffer, it is expanded to accommodate. @param index the index in the FastStringBuffer to startreplacing characters at. @param value a character array used for the replacementcontents. @exception StringIndexOutOfBoundsException if the index is invalid. @aribaapi documented
• au.id.jericho.lib.html.OutputDocument.replace()
• bibliothek.gui.DockStation.replace()
• bibliothek.gui.dock.perspective.PerspectiveStation.replace()
• bndtools.editor.model.IDocumentWrapper.replace()
• br.msf.commons.lang.EnhancedStringBuilder.replace()
• cc.sketchchair.sketch.SketchShape.replace()
• client.net.sf.saxon.ce.regex.ARegularExpression.replace()
  Replace all substrings of a supplied input string that match the regular expression with a replacement string. @param input the input string on which replacements are to be performed @param replacement the replacement string in the format of the XPath replace() function @return the result of performing the replacement @throws XPathException if the replacement string is invalid
• com.adito.boot.ReplacementEngine.replace()
  Replace all occurences of all registered pattern in the provided string and return the result as a second string @param input input string @return processed string
• com.adito.core.stringreplacement.VariableReplacement.replace()
• com.browseengine.bobo.sort.DocIDPriorityQueue.replace()
• com.caucho.config.types.AnnotationConfig.replace()
• com.caucho.config.types.CustomBeanConfig.replace()
• com.cburch.logisim.circuit.CircuitMutation.replace()
• com.citytechinc.cq.component.annotations.widgets.rte.FindReplace.replace()
• com.dci.intellij.dbn.language.common.element.impl.QualifiedIdentifierVariant.replace()
• com.dubture.getcomposer.core.collection.JsonArray.replace()
• com.eviware.soapui.support.types.StringToStringsMap.replace()
• com.facebook.presto.jdbc.internal.netty.channel.ChannelPipeline.replace()
  Replaces the specified {@link ChannelHandler} with a new handler inthis pipeline. @throws NoSuchElementException if the specified old handler does not exist in this pipeline @throws IllegalArgumentException if a handler with the specified new name already exists in this pipeline, except for the handler to be replaced @throws NullPointerException if the specified old handler, new name, or new handler is {@code null}
• com.fasterxml.jackson.databind.node.ObjectNode.replace()
  Method for replacing value of specific property with passed value, and returning value (or null if none). @param fieldName Property of which value to replace @param value Value to set property to, replacing old value if any @return Old value of the property; null if there was no such propertywith value @since 2.1
• com.gargoylesoftware.htmlunit.html.DomNode.replace()
  Replaces this node with another node. If the specified node is this node, this method is a no-op. @param newNode the node to replace this one @throws IllegalStateException if this node is not a child of any other node
• com.github.sommeri.less4j.core.compiler.stages.ASTManipulator.replace()
• com.github.sommeri.less4j.js.JsRegExp.replace()
  Returns the input string with the part(s) matching the regular expression replaced with the replacement string. If the global flag is set, replaces all matches of the regular expression. Otherwise, replaces the first match of the regular expression. As per Javascript semantics, backslashes in the replacement string get no special treatment, but the replacement string can use the following special patterns: $1, $2, ... $99 - inserts the n'th group matched by the regular expression. $& - inserts the entire string matched by the regular expression. $$ - inserts a $. Note: $` and $' are *not* supported in the pure Java implementation, and throw an exception. Parameters: input the string in which the regular expression is to be searched. replacement the replacement string. Returns: the input string with the regular expression replaced by the replacement string. Throws: RuntimeException if replacement is invalid
• com.google.gerrit.common.data.ParameterizedString.replace()
  Format this string by performing the variable replacements.
• com.google.gerrit.server.git.ProjectConfig.replace()
• com.google.gwt.query.client.builders.JsniBundle.LibrarySource.replace()
• com.google.gwt.query.client.builders.JsniBundle.MethodSource.replace()
• com.google.gwt.regexp.shared.RegExp.replace()
  Returns the input string with the part(s) matching the regular expression replaced with the replacement string. If the global flag is set, replaces all matches of the regular expression. Otherwise, replaces the first match of the regular expression. As per Javascript semantics, backslashes in the replacement string get no special treatment, but the replacement string can use the following special patterns:

  • $1, $2, ... $99 - inserts the n'th group matched by the regular expression.
  • $& - inserts the entire string matched by the regular expression.
  • $$ - inserts a $.

  Note: $` and $' are *not* supported in the pure Java implementation, and throw an exception. @param input the string in which the regular expression is to be searched. @param replacement the replacement string. @return the input string with the regular expression replaced by thereplacement string. @throws RuntimeException if {@code replacement} is invalid
• com.google.wave.api.BlipContentRefs.replace()
  Replaces the matched positions with the given arguments. @param arguments the new contents to replace the original contents. @return an instance of this blip references, for chaining.
• com.google.wave.api.FormView.replace()
• com.hazelcast.core.IMap.replace()
  {@inheritDoc}

  Warning:

  This method uses hashCode and equals of binary form of the key, not the actual implementations of hashCode and equals defined in key's class. @throws NullPointerException if any of the specified parameters are null
• com.hazelcast.core.TransactionalMap.replace()
  Transactional implementation of {@link com.hazelcast.core.IMap#replace(Object,Object)}.

  The object to be replaced will be accessible only in the current transaction context till transaction is committed. @see IMap#replace(Object,Object)

• com.hp.hpl.jena.rdf.model.RDFList.replace()

  Replace the value at the i'th position in the list with the given value. If the list is too short to have an i'th element, throws a {@link ListIndexException}.

  @param i The index into the list, from 0 @param value The new value to associate with the i'th list element @return The value that was previously at position i in the list @exception ListIndexException if the list has fewer than (i + 1)elements.
• com.ibm.richtext.styledtext.MText.replace()
  Replace the characters and styles in the range [start, limit) with the characters and styles in srcText in the range [srcStart, srcLimit). srcText is not modified. @param start the offset at which the replace operation begins @param limit the offset at which the replace operation ends. The character and style atlimit is not modified. @param srcText the source for the new characters and styles @param srcStart the offset into srcText where new characters and styles will be obtained @param srcLimit the offset into srcText where the new characters and styles end
• com.ibm.richtext.styledtext.StyledText.replace()
  Replace the characters and styles in the range [start, limit) with the characters and styles in srcText in the range [srcStart, srcLimit). srcText is not modified. @param start the offset at which the replace operation begins @param limit the offset at which the replace operation ends. The character and style atlimit is not modified. @param text the source for the new characters and styles @param srcStart the offset into srcText where new characters and styles will be obtained @param srcLimit the offset into srcText where the new characters and styles end
• com.intellij.openapi.util.TextRange.replace()
• com.intellij.psi.PsiElement.replace()
  Replaces this PSI element (along with all its children) with another element (along with the children). @param newElement the element to replace this element with. @return the element which was actually inserted in the tree (either newElement or its copy) @throws IncorrectOperationException if the modification is not supported or not possible for some reason.
• com.intellij.psi.PsiImportList.replace()
• com.intellij.psi.css.CssElement.replace()
• com.knowgate.addrbook.Meeting.replace()
• com.knowgate.crm.Contact.replace()
• com.knowgate.dataobjs.DBPersist.replace()

  Replace a value from internal collection

  @param sKey Field Name @param oObj New Value
• com.knowgate.hipergate.Category.replace()
• com.knowgate.hipergate.Product.replace()
• com.knowgate.scheduler.Atom.replace()
• com.l2jfrozen.gameserver.network.serverpackets.NpcHtmlMessage.replace()
  Replace. @param pattern the pattern @param value the value
• com.liferay.maven.plugins.util.ContextReplace.replace()
• com.lowagie.text.xml.xmp.XmpReader.replace()
  Replaces the content of a tag. @param namespaceURI the URI of the namespace @param localName the tag name @param value the new content for the tag
• com.nexirius.util.XString.replace()
  replace every occurence of 'from' with 'to' @return the number of replacements
• com.ning.http.client.FluentCaseInsensitiveStringsMap.replace()
  Replaces the values for the given key with the given values. @param key The key @param values The new values @return This object
• com.projity.pm.dependency.Dependency.replace()
• com.redspr.redquerybuilder.core.client.BaseSqlWidget.replace()
• com.sirenian.hellbound.domain.Segments.replace()
  @throws IllegalArgumentException if the Segment being removed is notcontained in this Segments.
• com.sun.enterprise.admin.util.LineTokenReplacer.replace()
• com.tll.util.PropertyPath.replace()
  Replaces a node path String. @param nodePath The target node path String to replace. @param replNodePath The replacement node path String. @return true if the replacement was successful.
• com.trolltech.qt.core.QByteArray.replace()
• com.volantis.mcs.dom.Element.replace()
• com.volantis.mcs.dom.Text.replace()
• com.xixibase.cache.CacheClient.replace()
  Replace one object to remote Xixibase server and with no expiration.

   if the object is exist in Xixibase server update xixibase set xixibase.value = value xixibase.expiration = NO_EXPIRATION where xixibase.key = key else return 0; 

  @param key @param value @return 0 if operation failed, else return the cacheID of the object
• de.iritgo.aktera.util.string.SuperString.replace()
  replace substrings within string. @param s @param sub @param with @return
• de.sub.goobi.helper.VariableReplacer.replace()
  Variablen innerhalb eines Strings ersetzen. Dabei vergleichbar zu Ant die Variablen durchlaufen und aus dem Digital Document holen ================================================================
• de.sub.goobi.helper.VariableReplacerWithoutHibernate.replace()
  Variablen innerhalb eines Strings ersetzen. Dabei vergleichbar zu Ant die Variablen durchlaufen und aus dem Digital Document holen ================================================================
• edu.stanford.ppl.concurrent.SnapTreeMap.replace()
• freenet.client.filter.FilterMIMEType.replace()
• gnu.java.lang.CPStringBuilder.replace()
• gnu.testlet.javax.swing.text.FlowView.TestFlowView.replace()
• gnu.trove.list.TIntList.replace()
  Sets the value at the specified offset and returns the previously stored value. @param offset an int value @param val an int value @return the value previously stored at offset.
• gov.nasa.jpf.vm.NativeMethodInfo.replace()
• io.netty.channel.ChannelPipeline.replace()
  Replaces the specified {@link ChannelHandler} with a new handler inthis pipeline. All the remaining content in the {@link} Buf) (if any) of the {@link ChannelHandler}will be discarded. @param oldHandler the {@link ChannelHandler} to be replaced @param newName the name under which the replacement should be added @param newHandler the {@link ChannelHandler} which is used as replacement @return itself @throws NoSuchElementException if the specified old handler does not exist in this pipeline @throws IllegalArgumentException if a handler with the specified new name already exists in this pipeline, except for the handler to be replaced @throws NullPointerException if the specified old handler, new name, or new handler is {@code null}
• it.unimi.dsi.lang.MutableString.replace()
• java.io.File.replace()
• java.lang.String.replace()
  Returns a new string resulting from replacing all occurrences of oldChar in this string with newChar.

  If the character oldChar does not occur in the character sequence represented by this String object, then a reference to this String object is returned. Otherwise, a new String object is created that represents a character sequence identical to the character sequence represented by this String object, except that every occurrence of oldChar is replaced by an occurrence of newChar.

  Examples:

   "mesquite in your cellar".replace('e', 'o') returns "mosquito in your collar" "the war of baronets".replace('r', 'y') returns "the way of bayonets" "sparring with a purple porpoise".replace('p', 't') returns "starring with a turtle tortoise" "JonL".replace('q', 'x') returns "JonL" (no change) 

  @param oldChar the old character. @param newChar the new character. @return a string derived from this string by replacing everyoccurrence of oldChar with newChar.
• java.lang.StringBuffer.replace()
  @throws StringIndexOutOfBoundsException {@inheritDoc} @since 1.2
• java.util.concurrent.ConcurrentNavigableMap.replace()
• java.util.regex.Pattern.replace()
• javax.jcache.CacheAccess.replace()
• javax.swing.GroupLayout.replace()
  Replaces an existing component with a new one. @param existingComponent the component that should be removedand replaced with {@code newComponent} @param newComponent the component to put in{@code existingComponent}'s place @throws IllegalArgumentException if either of the components are{@code null} or {@code existingComponent} is not being managedby this layout manager
• javax.swing.text.AbstractDocument.replace()
• javax.swing.text.AbstractDocument.BranchElement.replace()
• javax.swing.text.PlainDocument.replace()
• jregex.Replacer.replace()
• ket.Edit.replace()
  In order to take into account the current selection while replacing, it should be done through this method rather than via branch.replace().
• ket.Selection.replace()
• l2p.gameserver.serverpackets.NpcHtmlMessage.replace()
• lineage2.gameserver.model.pledge.SubUnit.replace()
  Method replace. @param objectId int @param newUnitId int
• lineage2.gameserver.network.serverpackets.NpcHtmlMessage.replace()
• lipstone.joshua.parser.util.ConsCell.replace()
  Replaces this ConsCell with replacement, and returns the first ConsCell in replacement.
  If replacement's cdr is another ConsCell, it inserts the entirety of replacement into this ConsCell, but only over-writes the first one. @param replacement the new ConsCell @return the first ConsCell in replacement
• lombok.val.replace()
• lupos.engine.operators.tripleoperator.TriplePattern.replace()
• net.htmlparser.jericho.OutputDocument.replace()
  Replaces the specified {@linkplain Segment segment} in this output document with the specified text.

  Specifying a null argument to the text parameter is exactly equivalent to specifying an empty string, and results in the segment being completely removed from the output document. @param segment the segment to replace. @param text the replacement text, or null to remove the segment.

• net.infopeers.commons.regex.Replacer.replace()
• net.openhft.collections.SharedHashMap.replace()
• net.rim.device.api.system.RuntimeStore.replace()
• net.rim.device.api.ui.Manager.replace()
• net.sf.ehcache.Cache.replace()
  {@inheritDoc}
• net.sf.l2j.gameserver.serverpackets.NpcHtmlMessage.replace()
• net.sf.saxon.regex.RegularExpression.replace()
  Replace all substrings of a supplied input string that match the regular expression with a replacement string. @param input the input string on which replacements are to be performed @param replacement the replacement string in the format of the XPath replace() function @return the result of performing the replacement @throws XPathException if the replacement string is invalid
• net.sourceforge.temply.base.VarExpressionFinder.replace()
• net.spy.memcached.MemcachedClient.replace()
  Replace an object with the given value iff there is already a value for the given key.

  The exp value is passed along to memcached exactly as given, and will be processed per the memcached protocol specification:

  The actual value sent may either be Unix time (number of seconds since January 1, 1970, as a 32-bit value), or a number of seconds starting from current time. In the latter case, this number of seconds may not exceed 60*60*24*30 (number of seconds in 30 days); if the number sent by a client is larger than that, the server will consider it to be real Unix time value rather than an offset from current time.

  @param key the key under which this object should be added. @param exp the expiration of this object @param o the object to store @return a future representing the processing of this operation
• net.timewalker.ffmq3.storage.message.MessageStore.replace()
  Replace a message in the store @param handle message handle @param message the message to store
• net.yacy.kelondro.index.Index.replace()
• noop.model.Library.replace()
• org.antlr.runtime.TokenRewriteStream.replace()
• org.antlr.v4.runtime.TokenStreamRewriter.replace()
• org.apache.cassandra.db.compaction.LeveledManifest.replace()
• org.apache.commons.lang.text.StrSubstitutor.replace()
  Replaces all the occurrences of variables in the given source object with their matching values from the map. @param source the source text containing the variables to substitute, null returns null @param valueMap the map with the values, may be null @return the result of the replace operation
• org.apache.commons.lang3.text.StrSubstitutor.replace()
  Replaces all the occurrences of variables in the given source object with their matching values from the map. @param source the source text containing the variables to substitute, null returns null @param valueMap the map with the values, may be null @return the result of the replace operation
• org.apache.derby.iapi.store.access.ConglomerateController.replace()
  Replace the (partial) row at the given location. @return true if update was successful, returns false if the update fails because the record pointed at no longer represents a valid record. @exception StandardException Standard exception policy. @see RowUtil
• org.apache.derby.iapi.store.access.ScanController.replace()
  Replace the (partial) row at the current position of the scan. @return true if the replace was successful,false if the current position is no longer valid (ie. if it was deleted). @exception StandardException Standard exception policy. @see RowUtil
• org.apache.directory.api.ldap.model.message.ModifyRequest.replace()
  @see #replace(String,String)
• org.apache.directory.api.ldap.model.message.ModifyRequestImpl.replace()
  @see #replace(String,String)
• org.apache.directory.ldap.client.api.message.ModifyRequest.replace()
  marks a given attribute for replacement with the given values in the target entry. @param attributeName name of the attribute to be added @param attributeValue values of the attribute
• org.apache.directory.shared.ldap.model.message.ModifyRequest.replace()
  @see #replace(String,String)
• org.apache.directory.shared.ldap.model.message.ModifyRequestImpl.replace()
  @see #replace(String,String)
• org.apache.james.mailbox.model.MailboxACL.replace()
  Replaces the entry corresponding to the given {@code key} with{@code toAdd}link MailboxACLRights}. Implementations must return a new unmodifiable instance of {@link MailboxACL}. However, implementations may decide to return this in case the result would be equal to it. Implementations must ensure that the result does not contain entries with empty rigths. E.g. "user1:lr;user2:lrwt".replace("user1", MailboxACLRights.EMPTY) should return "user2:lrwt" rather than "user1:;user2:lrwt". The same result should be returned by "user1:lr;user2:lrwt".replace("user1", null). @param key @param toAdd @return @throws UnsupportedRightException
• org.apache.jmeter.control.ReplaceableController.replace()
  Used to replace the test execution tree (usually by adding the subelements of the TestElement that is replacing the ReplaceableController. @param tree - The current HashTree to be executed. @see org.apache.jorphan.collections.HashTree @see org.apache.jmeter.gui.action.AbstractAction#convertSubTree
• org.apache.logging.log4j.core.lookup.StrSubstitutor.replace()
  Replaces all the occurrences of variables in the given source object with their matching values from the map. @param source the source text containing the variables to substitute, null returns null @param valueMap the map with the values, may be null @return the result of the replace operation
• org.apache.maven.index.context.IndexingContext.replace()
  Replaces the Lucene index with the one from supplied directory. @param directory @throws IOException
• org.apache.pig.backend.hadoop.executionengine.physicalLayer.plans.PhysicalPlan.replace()
• org.apache.pig.newplan.logical.relational.LogicalPlan.replace()
• org.apache.sling.resourceresolver.impl.mapping.MapEntry.replace()
• org.apache.wicket.MarkupContainer.replace()
  Replaces a child component of this container with another @param child The child @throws IllegalArgumentException Thrown if there was no child with the same id. @return This
• org.apache.wicket.MockPageWithLink.replace()
• org.apache.wicket.MockPageWithLinkAndComponent.replace()
• org.apache.wicket.Page.replace()
• org.apache.wicket.markup.html.WebMarkupContainer.replace()
• org.apache.wicket.markup.html.panel.Panel.replace()
• org.apache.yoko.orb.CORBA.Any.replace()
• org.beryl.gui.model.TableRow.replace()
• org.camunda.bpm.engine.impl.pvm.runtime.PvmExecutionImpl.replace()
• org.cfeclipse.cfml.editors.ICFDocument.replace()
• org.codehaus.groovy.classgen.asm.OperandStack.replace()
  replace top level element with new element of given type
• org.dspace.content.packager.PackageIngester.replace()
  Replace an existing Item with contents of the ingested package. The packager may choose not to implement replace, since it somewhat contradicts the archival nature of DSpace. The exact function of this method is highly implementation-dependent. @param context DSpace context. @param item existing item to be replaced @param in input stream containing package to ingest. @param params Properties-style list of options specific to this packager @return item re-created by ingest. @throws PackageValidationException if package is unacceptable or there isa fatal error turning it into an Item. @throws UnsupportedOperationException if this packager does notimplement replace.
• org.eclipse.imp.pdb.facts.IList.replace()
• org.eclipse.imp.pdb.facts.INode.replace()
• org.eclipse.imp.pdb.facts.IString.replace()
• org.eclipse.jdt.core.IBuffer.replace()
  Replaces the given range of characters in this buffer with the given text. position and position + length must be in the range [0, getLength()]. length must not be negative.

  Has no effect if this buffer is read-only or if the buffer is closed. @param position the zero-based starting position of the affected text range in this buffer @param length the length of the affected text range in this buffer @param text the replacing text as a character array

• org.eclipse.jdt.core.dom.rewrite.ASTRewrite.replace()
  Replaces the given node in this rewriter. The replacement node must either be brand new (not part of the original AST) or a placeholder node (for example, one created by {@link #createCopyTarget(ASTNode)}or {@link #createStringPlaceholder(String,int)}). The AST itself is not actually modified in any way; rather, the rewriter just records a note that this node has been replaced. @param node the node being replaced. The node can either be an original node in the ASTor (since 3.4) a new node already inserted or used as replacement in this AST rewriter. @param replacement the replacement node, or null if noreplacement @param editGroup the edit group in which to collect the correspondingtext edits, or null if ungrouped @throws IllegalArgumentException if the node is null, or if the node is not partof this rewriter's AST, or if the replacement node is not a new node (or placeholder), or if the described modification is otherwise invalid
• org.eclipse.jdt.core.dom.rewrite.ListRewrite.replace()
  Replaces the given node from its parent's list property in the rewriter. The node must be contained in the list. The replacement node must either be brand new (not part of the original AST) or a placeholder node (for example, one created by {@link ASTRewrite#createCopyTarget(ASTNode)}, {@link ASTRewrite#createMoveTarget(ASTNode)}, or {@link ASTRewrite#createStringPlaceholder(String,int)}). The AST itself is not actually modified in any way; rather, the rewriter just records a note that this node has been replaced in this list. @param node the node being removed. The node can either be an original node in this listor (since 3.4) a new node already inserted or used as replacement in this AST rewriter. @param replacement the replacement node, or null if noreplacement @param editGroup the edit group in which to collect the correspondingtext edits, or null if ungrouped @throws IllegalArgumentException if the node is null, or if the node is not partof this rewriter's AST, or if the replacement node is not a new node (or placeholder), or if the described modification is otherwise invalid (not a member of this node's original list)
• org.eclipse.jface.text.Document.replace()
• org.eclipse.jface.text.FindReplaceDocumentAdapter.replace()
  Substitutes the previous match with the given text. Sends a DocumentEvent to all registered IDocumentListener. @param text the substitution text @param regExReplace if true text represents a regular expression @return the replace region or null if there was no match @throws BadLocationException if startOffset is an invalid document offset @throws IllegalStateException if a REPLACE or REPLACE_FIND operation is not preceded by a successful FIND operation @throws PatternSyntaxException if a regular expression has invalid syntax @see DocumentEvent @see IDocumentListener
• org.eclipse.jface.text.IDocument.replace()
  Substitutes the given text for the specified document range. Sends a DocumentEvent to all registered IDocumentListener. @param offset the document offset @param length the length of the specified range @param text the substitution text @exception BadLocationException if the offset is invalid in this document @see DocumentEvent @see IDocumentListener
• org.eclipse.jface.text.ILineTracker.replace()
  Informs the line tracker about the specified change in the tracked text. @param offset the offset of the replaced text @param length the length of the replaced text @param text the substitution text @exception BadLocationException if specified range is unknown to this tracker
• org.eclipse.ocl.EvaluationEnvironment.replace()
• org.eclipse.php.internal.core.ast.rewrite.ASTRewrite.replace()
  Replaces the given node in this rewriter. The replacement node must either be brand new (not part of the original AST) or a placeholder node (for example, one created by {@link #createCopyTarget(ASTNode)} or{@link #createStringPlaceholder(String,int)}). The AST itself is not actually modified in any way; rather, the rewriter just records a note that this node has been replaced. @param node the node being replaced @param replacement the replacement node, or null if no replacement @param editGroup the edit group in which to collect the corresponding text edits, or null if ungrouped @throws IllegalArgumentException if the node is null, or if the node is not part of this rewriter's AST, or if the replacement node is not a new node (or placeholder), or if the described modification is otherwise invalid
• org.eclipse.php.internal.core.ast.rewrite.ListRewrite.replace()
  Replaces the given node from its parent's list property in the rewriter. The node must be contained in the list. The replacement node must either be brand new (not part of the original AST) or a placeholder node (for example, one created by {@link ASTRewrite#createCopyTarget(ASTNode)}, {@link ASTRewrite#createMoveTarget(ASTNode)}, or {@link ASTRewrite#createStringPlaceholder(String,int)}). The AST itself is not actually modified in any way; rather, the rewriter just records a note that this node has been replaced in this list. @param node the node being replaced @param replacement the replacement node, or null if no replacement @param editGroup the edit group in which to collect the corresponding text edits, or null if ungrouped @throws IllegalArgumentException if the node is null, or if the node is not part of this rewriter's AST, or if the replacement node is not a new node (or placeholder), or if the described modification is otherwise invalid (not a member of this node's original list)
• org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocument.replace()
• org.eclipse.xtext.ui.editor.model.IXtextDocument.replace()
• org.fife.ui.rsyntaxtextarea.RSyntaxDocument.replace()
• org.glassfish.grizzly.memory.CompositeBuffer.replace()
  Replace one internal {@link Buffer} with another one. @param oldBuffer the {@link Buffer} to replace. @param newBuffer the new {@link Buffer}. @return true, if the oldBuffer was found and replaced, orfalse otherwise.
• org.h2.table.TableView.replace()
  Try to replace the SQL statement of the view and re-compile this and all dependent views. @param querySQL the SQL statement @param columnNames the column names @param session the session @param recursive whether this is a recursive view @param force if errors should be ignored
• org.infinispan.Cache.replace()
  An overloaded form of {@link #replace(Object,Object)}, which takes in lifespan parameters. @param key key to use @param value value to store @param lifespan lifespan of the entry. Negative values are intepreted as unlimited lifespan. @param unit unit of measurement for the lifespan @return the value being replaced, or null if nothing is being replaced.
• org.intellij.erlang.psi.ErlangTypedRecordFields.replace()
• org.jboss.netty.channel.ChannelPipeline.replace()
  Replaces the specified {@link ChannelHandler} with a new handler inthis pipeline. @throws NoSuchElementException if the specified old handler does not exist in this pipeline @throws IllegalArgumentException if a handler with the specified new name already exists in this pipeline, except for the handler to be replaced @throws NullPointerException if the specified old handler, new name, or new handler is {@code null}
• org.jclouds.openstack.swift.v1.features.ObjectApi.replace()
  pi/openstack-object-storage/1.0/content/create-update-object.html"> Create or Update Object API @return {@link SwiftObject#etag()} of the object.
• org.jetbrains.lang.manifest.psi.Header.replace()
• org.jgroups.util.MessageBatch.replace()
  Replaces a message in the batch with another one @param existing_msg The message to be replaced. The message has to be non-null and is found by identity (==)comparison @param new_msg The message to replace the existing message with, can be null @return
• org.jitterbit.ui.util.find.SearchAndReplaceTextTarget.replace()
• org.jregex.Replacer.replace()
• org.jruby.util.ByteList.replace()
• org.kitesdk.data.spi.StorageKey.replace()
  Replaces the value at {@code index} with the given {@code value}. @param index the {@code index} of the field to replace @param value an Object to store at {@code index}
• org.lealone.dbobject.table.TableView.replace()
  Try to replace the SQL statement of the view and re-compile this and all dependent views. @param querySQL the SQL statement @param columnNames the column names @param session the session @param recursive whether this is a recursive view @param force if errors should be ignored
• org.locationtech.udig.catalog.ICatalog.replace()
• org.pdf4j.saxon.regex.RegularExpression.replace()
  Replace all substrings of a supplied input string that match the regular expression with a replacement string. @param input the input string on which replacements are to be performed @param replacement the replacement string in the format of the XPath replace() function @return the result of performing the replacement @throws XPathException if the replacement string is invalid
• org.red5.server.api.stream.IPlaylistSubscriberStream.replace()
  Replaces an item in the list with another item. @param oldItem @param newItem @return true if successful and false otherwise
• org.resmedicinae.resmedlib.term.String.replace()
• org.slf4j.migrator.line.MultiGroupConversionRule.replace()
• org.sonatype.sisu.goodies.common.io.FileReplacer.replace()
• org.springframework.core.env.MutablePropertySources.replace()
  Replace the property source with the given name with the given property source object. @param name the name of the property source to find and replace @param propertySource the replacement property source @throws IllegalArgumentException if no property source with the given name is present @see #contains
• org.waveprotocol.wave.model.document.AnnotationBehaviour.replace()
  Defines which side of the cursor to inherit annotations from, given the current state of annotations and some information about what the annotations are being set over. Note that in the case of ranged selections being replaced, the cursor is considered to have the same annotations as the first character of the selected range. @param inside Key-Value mappings for annotations inside the cursor. @param outside Key-Value mappings for annotations outside the cursor. @param type Type of content being replaced @return Desired inheritence behaviour.
• org.xbill.DNS.Update.replace()
  Parses a record from the string, and indicates that the record should be inserted into the zone replacing any other records with the same name and type. @throws IOException The record could not be parsed.
• org.xmlBlaster.contrib.InfoHelper.replace()
• org.xmlBlaster.util.ReplaceVariable.replace()
  Replace dynamic variables, e.g. ${XY} with their values.

  The maximum replacement (nesting) depth is 50. @param text The value string which may contain zero to many ${...} variables @param cb The callback supplied by you which replaces the found keys (from ${key}) @return The new value where all resolvable ${} are replaced. @throws IllegalArgumentException if matching "}" is missing

• ro.redeul.google.go.lang.psi.toplevel.GoImportDeclarations.replace()
• rocket.widget.client.Hijacker.replace()
  Replaces the element contained with the given element. @param element
• water.fvec.Frame.replace()
• water.util.RString.replace()

Examples of javax.swing.text.AbstractDocument.replace()

Examples of javax.swing.text.AbstractDocument.BranchElement.replace()

Examples of javax.swing.text.PlainDocument.replace()

Examples of jregex.Replacer.replace()

Examples of ket.Edit.replace()

Examples of ket.Selection.replace()

Examples of l2p.gameserver.serverpackets.NpcHtmlMessage.replace()

Examples of lineage2.gameserver.model.pledge.SubUnit.replace()

Examples of lineage2.gameserver.network.serverpackets.NpcHtmlMessage.replace()

Examples of lipstone.joshua.parser.util.ConsCell.replace()