Public

setBody

removeAttribute

removeElement

setAttribute

replaceWith

setLocalVariable

insertBefore

insertImmediatelyAfter

replaceAttribute

removeTags

 Instructs the engine to iterate the current element, applying a specific
iteration configuration.



iterateElement

 Instructs the engine to remove all the children of the element being processed,
except the first on

removeAllButFirstChild

 Instructs the engine to remove the body of the element being processed, but
keep the open and close

removeBody

 Instructs the engine to set a new inliner.

 Inliners are used for processing all text nodes ( org.

setInliner

 Instructs the engine to set a new selection target.

 The selection target is the object on which s

setSelectionTarget

 Instructs the engine to set a new template data.

 This method modifies the metadata about the temp

setTemplateData

List

Start an intent from android

A component is an object having a graphical representation that can be displayed
on the screen and t

java.awt.Component

A BufferedInputStream adds functionality to another input stream-namely, the
ability to buffer the i

java.io.BufferedInputStream

java.net.Socket

This exception is thrown when a timeout expired on a socket read or accept
operation.

java.net.SocketTimeoutException

The BitSet class implements abit array [http://en.wikipedia.org/wiki/Bit_array].
Each element is eit

java.util.BitSet

A Set is a data structure which does not allow duplicate elements.

java.util.Set

getContentResolver

setRequestProperty

scheduleAtFixedRate

"and 'all-but-first' are allowed, but \""

// This is merely a FragmentExpression (not complex, not combined with anything), so we can apply a shortcut

// so that we don't require a "null" result for this expression if the template does not exist. That will

// save a call to resource.exists() which might be costly.

// If result is no-op, there's nothing to execute

/*
         * First of all we should check whether the expression result is a Fragment so that, in such case, we can
         * avoid creating a String in memory for it and just append its model.
         */

/*
         * We will check if there are configured post processors or not. The reason we do this is because output
         * inserted as a result of a th:utext attribute, even if it might be markup, will never be considered as
         * 'processable', i.e. no other processors/inliner will ever be able to act on it. The main reason for this
         * is to protect against code injection.
         *
         * So the only other agents that would be able to modify these th:utext results are POST-PROCESSORS. And
         * they will indeed need markup to have been parsed in order to separate text from structures, so that's why
         * we check if there actually are any post-processors and, if not (most common case), simply output the
         * expression result as if it were a mere (unescaped) text node.
         */

/*
         * We have post-processors, so from here one we will have to decide whether we need to parse the unescaped
         * text or not...
         */

// If this text contains no markup structures, there would be no need to parse it or treat it as markup!

/*
         * We have post-processors AND this text might contain structures, so there is no alternative but parsing
         */

// we won't apply offset here because the inserted text does not really come from the template itself

// useCache == false because we could potentially pollute the cache with too many entries (th:utext is too variable!)

// Setting 'processable' to false avoiding text inliners processing already generated text,

"Fragment specifications cannot be empty"

/*
         * PARSE AND PROCESS THE FRAGMENT
         */

// If the Fragment result is null, this is an error. Note a NULL result is not the same as the

"template or fragment could not be resolved"

// If the Fragment result is NO-OP, we will just do nothing (apart from deleting the th:* attribute)

// The result is the empty fragment, which means we simply have to either remove the body of this

// tag (th:insert) or remove it completely, tag included (th:replace)

/*
         * ONCE WE HAVE THE FRAGMENT MODEL (its events, in fact), CHECK THE FRAGMENT SIGNATURE
         * Fragment signature is important because it might affect the way we apply the parameters to the fragment.
         *
         * Note this works whatever the template mode of the inserted fragment, given we are looking for an
         * element containing a "th:fragment/data-th-fragment" in a generic, non-template-dependent way.
         */

// We will check types first instead of events in order to (many times) avoid creating an immutably-wrapped

// event object when calling "model.get(pos)"

// The selected fragment actually has a "th:fragment" attribute, so we should process its signature

// Reshape the fragment parameters into the ones that we will actually use, according to the signature

// If no signature applied, we must check if the parameters map contains synthetic parameters. If so,

// we should raise an exception because not doing so could provoke confusion in users who would see parameters

// not being applied, maybe not realising there was no signature assignation involved.

"' specifies synthetic (unnamed) parameters, but the resolved fragment "

"does not match a fragment signature (th:fragment,data-th-fragment) which could apply names to "

/*
         * CHECK WHETHER THIS IS A CROSS-TEMPLATE-MODE INSERTION. Only TemplateModels for the same template mode
         * can be safely inserted into the template being executed and processed just like any other sequences of
         * events. If the inserted template has a different template mode, we will need to process it aside and
         * obtain a String result for it, then insert such String as mere text.
         *
         * Note inserting large templates with a different template mode could therefore have a negative effect
         * on performance and memory usage, as their result needs to be completely stored in memory at some point
         * before being handled to the following phases of template processing. It is therefore recommended that
         * cross-template-mode fragment insertion is done only for small fragments, in which case it will work
         * almost the same as inlining (with the exception that the content to be inlined will be retrieved from
         * somewhere else by means of template resolution).
         */

// Check if this is a th:include. If so, just don't allow

"Template being processed uses template mode "

". Cross-template-mode fragment insertion is not "

" attribute, which is no longer recommended for use as "

"of Thymeleaf 3.0. Use {th:insert,data-th-insert} or {th:replace,data-th-replace} "

"instead, which do not remove the container element from the fragment being inserted."

// If there are parameters specified, we will need to add them directly to the variables map instead of

// doing it through the structure handler (we are going to perform a nested template processing operation)

"Parameterized fragment insertion is not supported because local variable support is DISABLED. This is due to "

"not provide local-variable support. In order to have local-variable support, the variables map "

"implementation should also implement the "

// NOTE this IEngineContext interface is internal and should not be used in users' code

// Once parameters are in order, just process the template in a nested template engine execution

How to use removeBodymethodin org.thymeleaf.processor.element.IElementTagStructureHandler

Best Java code snippets using org.thymeleaf.processor.element.IElementTagStructureHandler.removeBody (Showing top 3 results out of 315)

How to use
removeBody
method
in
org.thymeleaf.processor.element.IElementTagStructureHandler