Public

getClassName

getName

getTypeQName

isAbstract

getCreateType

getExtensionTypes

getUri

topChildIterator

addChild

addTopChild

getAttributeComponents

getContentComponents

getNamespace

getTypeName

setAbstract

setClassName

setCreateType

setExtendsName

setFactoryName

setName

Connection

Running tasks concurrently on multiple threads

Wraps an existing Writer and buffers the output. Expensive interaction with the
underlying reader is

java.io.BufferedWriter

Wraps either an existing OutputStream or an existing Writerand provides
convenience methods for prin

java.io.PrintWriter

This class generates cryptographically secure pseudo-random numbers. It is best
to invoke SecureRand

java.security.SecureRandom

A Handler object accepts a logging request and exports the desired messages to a
target, for example

java.util.logging.Handler

Patterns are compiled regular expressions. In many cases, convenience methods
such as String#matches

java.util.regex.Pattern

A sequence of elements supporting sequential and parallel aggregate operations.
The following exampl

java.util.stream.Stream

getSupportFragmentManager

Return the contained value, if present, otherwise throw an exception to be
created by the provided s

orElseThrow

onRequestPermissionsResult

/**
     * Add the &lt;mapping&gt; definition for a typed collection to a binding. This always creates an abstract mapping with
     * the type name based on both the item type and the collection type, except in the case where an array is being
     * used in unwrapped (non-plain doc/lit) form.
     * 
     * @param doclit plain doc/lit handling flag
     * @param value collection value
     * @param typemap map from parameterized type to abstract mapping name
     * @param bind target binding
     * @return qualified name for collection
     */

// check for either not an array, or plain doc/lit

// create abstract mapping for collection class type

// generate the mapping type name from item class name and suffix

/**
     * Build classes and bindings for all definitions, except those for singleton element definitions using a type.
     *
     * @param defs definitions to be generated
     * @param typeinst map from base type definition to singleton element definition using that type
     */

// compact again after inlining and converting extension references

// build the binding component for this definition

// abstract or concrete mapping for element

// abstract mapping for type definition or group

// add the mapping to binding and set on class

// create mapping for element name linked to type

// handle linking to substitution group head using extends mapping

// create single structure child invoking the type mapping

// set the definition for the class (and create any required secondary classes)

/**
     * Add the &lt;mapping> definition for a class to a binding. This creates either an abstract mapping with a type
     * name, or a concrete mapping with an element name, as determined by the passed-in mapping information. If the
     * class is a concrete mapping that extends or implements another class with an anonymous abstract mapping, the
     * created &lt;mapping> will extend that base mapping. TODO: type substitution requires extending the binding
     * definition
     * 
     * @param type fully qualified class name
     * @param detail mapping details
     */

// make "concrete" mapping abstract if no class creation possible

// fill details directly to this mapping unless abstract also created

// use abstract mapping for details (concrete will reference this one)

// find the binding containing this mapping

// check for superclass mapping to be extended (do this first for compatibility with schema type extension)

// not extending a base mapping, check if need to include superclass

"Internal error: unimplemented case of superclass "

// set extension for child concrete mapping

// add extension reference structure to mapping

// add all details of class member handling to binding

// define content as structure reference to abstract mapping

// set the member property map for mapping

" with neither abstract nor concrete mapping"

How to use setAbstractmethodin org.jibx.binding.model.MappingElementBase

Best Java code snippets using org.jibx.binding.model.MappingElementBase.setAbstract (Showing top 3 results out of 315)

How to use
setAbstract
method
in
org.jibx.binding.model.MappingElementBase